@keetanetwork/anchor 0.0.64 → 0.0.65

package/lib/anchor-external.d.ts

@@ -0,0 +1,236 @@
+import type { lib as KeetaNetLib } from '@keetanetwork/keetanet-client';
+import { KeetaAnchorUserError } from './error.js';
+type Account = InstanceType<typeof KeetaNetLib.Account>;
+/**
+ * Current envelope format version.
+ */
+export declare const ANCHOR_EXTERNAL_VERSION = 1;
+/**
+ * Per-anchor entry.
+ */
+export type AnchorExternalEntry = {
+    /**
+     * Transaction id at the anchor.
+     */
+    transactionId: string;
+} | {
+    /**
+     * Persistent forwarding id at the anchor.
+     */
+    persistentForwardingId: string;
+} | {
+    /**
+     * Opaque destination data interpreted by the anchor (e.g. an EVM
+     * address for an EVM anchor).
+     */
+    destination: string;
+};
+/**
+ * Replay-protection binding for a signed envelope.
+ *
+ * Pins the signature to a specific position on the signer's account
+ * chain so the same signed envelope cannot be reused on a different
+ * operation or block.
+ */
+export type AnchorExternalBinding = {
+    /**
+     * Block hash that the signer's account had as its head when the
+     * SEND carrying this envelope was constructed.
+     */
+    previousBlockHash: string;
+    /**
+     * Index of the SEND operation within its block.
+     */
+    operationIndex: number;
+};
+/**
+ * Decoded anchor-external envelope as exposed to callers.
+ */
+export type AnchorExternalEnvelope = {
+    /**
+     * Envelope format version.
+     */
+    version: typeof ANCHOR_EXTERNAL_VERSION;
+    /**
+     * Per-anchor entries keyed by `Account.publicKeyString.get()`.
+     */
+    anchors: {
+        [anchorPublicKey: string]: AnchorExternalEntry;
+    };
+    /**
+     * Signature binding. Present if the envelope is signed.
+     */
+    binding?: AnchorExternalBinding;
+};
+/**
+ * Authenticity record attached to a verified signed envelope. Present only
+ * when the signature was verified and the signer appears in
+ * {@link AnchorExternalEnvelope.anchors}.
+ */
+export type AnchorExternalSigned = {
+    signer: Account;
+};
+/**
+ * Shape inspection result from {@link AnchorExternal.peek}.
+ */
+export type AnchorExternalPeekResult = {
+    encrypted: boolean;
+    signed: boolean;
+};
+/**
+ * Per-anchor entry as it appears in the encoded envelope.
+ *
+ * `t` = transaction id, `p` = persistent forwarding id, `d` = destination.
+ *
+ * Note: Single-letter keys keep the envelope smaller.
+ */
+export type EncodedAnchorExternalEntryV1 = {
+    t: string;
+} | {
+    p: string;
+} | {
+    d: string;
+};
+/**
+ * Replay-protection binding as it appears in the encoded envelope.
+ *
+ * `p` = previous block hash, `o` = operation index.
+ */
+export type EncodedAnchorExternalBindingV1 = {
+    p: string;
+    o: number;
+};
+/**
+ * Anchor-external envelope as it appears inside the encoded blob.
+ *
+ * `v` = envelope version, `a` = anchors, `b` = binding.
+ */
+export type EncodedAnchorExternalEnvelopeV1 = {
+    v: typeof ANCHOR_EXTERNAL_VERSION;
+    a: {
+        [anchorPublicKey: string]: EncodedAnchorExternalEntryV1;
+    };
+    b?: EncodedAnchorExternalBindingV1;
+};
+/**
+ * Error codes for anchor-external envelope operations.
+ */
+export declare const AnchorExternalErrorCodes: readonly ["BAD_BASE64", "NOT_AN_ENVELOPE", "UNSUPPORTED_VERSION", "NON_CANONICAL", "PLAINTEXT_TOO_LARGE", "BAD_SIGNATURE", "SIGNER_NOT_LISTED", "MISSING_BINDING", "UNEXPECTED_BINDING", "EXPECTED_PLAIN", "EXPECTED_ENCRYPTED", "OUTPUT_TOO_LARGE"];
+export type AnchorExternalErrorCode = typeof AnchorExternalErrorCodes[number];
+/**
+ * Error raised by anchor-external decode failures.
+ */
+export declare class AnchorExternalError extends KeetaAnchorUserError {
+    static readonly name: string;
+    private readonly anchorExternalErrorObjectTypeID;
+    private static readonly anchorExternalErrorObjectTypeID;
+    readonly code: AnchorExternalErrorCode;
+    /**
+     * Type-narrow an arbitrary string to {@link AnchorExternalErrorCode}.
+     */
+    static isValidCode(code: string): code is AnchorExternalErrorCode;
+    constructor(code: AnchorExternalErrorCode, message: string);
+    static isInstance(input: unknown): input is AnchorExternalError;
+    toJSON(): ReturnType<KeetaAnchorUserError['toJSON']> & {
+        code: AnchorExternalErrorCode;
+    };
+    static fromJSON(input: unknown): Promise<AnchorExternalError>;
+}
+/**
+ * Fluent builder for constructing an anchor-external envelope and producing
+ * its encoded SEND.external string.
+ */
+export declare class AnchorExternalBuilder {
+    #private;
+    /**
+     * Set the entry for a given anchor, replacing any prior entry
+     * for the same anchor.
+     */
+    setAnchor(anchor: Account, entry: AnchorExternalEntry): this;
+    /**
+     * Sign the produced envelope with the given account.
+     */
+    withSigner(signer: Account): this;
+    /**
+     * Encrypt the produced envelope so each listed principal can decrypt
+     * it. Omit to leave the envelope as plaintext.
+     */
+    withPrincipals(principals: Account[]): this;
+    /**
+     * Bind the produced signature to a position on the signer's
+     * account chain. Required whenever {@link withSigner} is used.
+     *
+     * @param previousBlockHash Block hash of the signer's current head.
+     * @param operationIndex    Index of the SEND operation within its block.
+     */
+    withBinding(previousBlockHash: string, operationIndex: number): this;
+    /**
+     * Set an upper bound on the encoded output length. {@link build}
+     * throws if the produced string would exceed this length.
+     */
+    withMaxLength(maxLength: number): this;
+    /**
+     * Snapshot of the envelope as it would be encoded right now.
+     */
+    toEnvelope(): AnchorExternalEnvelope;
+    /**
+     * Produce the encoded SEND.external string.
+     *
+     * @throws {@link KeetaAnchorError} on caller misuse.
+     */
+    build(): Promise<string>;
+}
+/**
+ * Immutable, verified view of a parsed SEND.external envelope.
+ */
+export declare class AnchorExternal {
+    #private;
+    static readonly Builder: typeof AnchorExternalBuilder;
+    private constructor();
+    /**
+     * Decoded envelope.
+     */
+    get envelope(): AnchorExternalEnvelope;
+    /**
+     * `true` if the source blob was encrypted.
+     */
+    get encrypted(): boolean;
+    /**
+     * Authenticity record for a verified signed envelope, or `undefined`
+     * if the envelope was not signed.
+     */
+    get signed(): AnchorExternalSigned | undefined;
+    /**
+     * Decode an external string asserted to be plaintext.
+     *
+     * @throws {@link AnchorExternalError} `EXPECTED_PLAIN` if the source blob is encrypted.
+     */
+    static fromPlainExternal(external: string): Promise<AnchorExternal>;
+    /**
+     * Decode an external string asserted to be encrypted under one of the
+     * supplied principals.
+     *
+     * @throws {@link AnchorExternalError} `EXPECTED_ENCRYPTED` if the source blob is plaintext.
+     * @throws {@link KeetaAnchorError} if `principals` is empty.
+     */
+    static fromEncryptedExternal(external: string, principals: Account[]): Promise<AnchorExternal>;
+    /**
+     * Inspect encrypted/signed flags of a candidate external string
+     * without reading plaintext or requiring a decryption key.
+     */
+    static peek(external: string): Promise<AnchorExternalPeekResult>;
+    /**
+     * Create an {@link AnchorExternal} from a container.
+     */
+    private static fromContainer;
+    /**
+     * Read the envelope from a container.
+     */
+    private static readEnvelope;
+    /**
+     * Read the signed record from a container.
+     */
+    private static readSigned;
+}
+export {};
+//# sourceMappingURL=anchor-external.d.ts.map

package/lib/anchor-external.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"anchor-external.d.ts","sourceRoot":"","sources":["../../src/lib/anchor-external.ts"],"names":[],"mappings":"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"}

package/lib/anchor-external.generated.d.ts

@@ -0,0 +1,3 @@
+import type { EncodedAnchorExternalEnvelopeV1 } from './anchor-external.js';
+export declare const assertEncodedAnchorExternalEnvelopeV1: (input: unknown) => EncodedAnchorExternalEnvelopeV1;
+//# sourceMappingURL=anchor-external.generated.d.ts.map

package/lib/anchor-external.generated.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"anchor-external.generated.d.ts","sourceRoot":"","sources":["../../src/lib/anchor-external.generated.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,+BAA+B,EAAE,MAAM,sBAAsB,CAAC;AAE5E,eAAO,MAAM,qCAAqC,EAAE,CAAC,KAAK,EAAE,OAAO,KAAK,+BAAuF,CAAC"}

package/lib/anchor-external.generated.js

@@ -0,0 +1,209 @@
+import * as __typia_transform__accessExpressionAsString from "typia/lib/internal/_accessExpressionAsString.js";
+import * as __typia_transform__assertGuard from "typia/lib/internal/_assertGuard.js";
+import { createAssertEquals } from 'typia';
+export const assertEncodedAnchorExternalEnvelopeV1 = (() => { const _io0 = (input, _exceptionable = true) => 1 === input.v && ("object" === typeof input.a && null !== input.a && false === Array.isArray(input.a) && _io1(input.a, true && _exceptionable)) && (undefined === input.b || "object" === typeof input.b && null !== input.b && _io5(input.b, true && _exceptionable)) && (2 === Object.keys(input).length || Object.keys(input).every(key => {
+    if (["v", "a", "b"].some(prop => key === prop))
+        return true;
+    const value = input[key];
+    if (undefined === value)
+        return true;
+    return false;
+})); const _io1 = (input, _exceptionable = true) => Object.keys(input).every(key => {
+    const value = input[key];
+    if (undefined === value)
+        return true;
+    return "object" === typeof value && null !== value && _iu0(value, true && _exceptionable);
+}); const _io2 = (input, _exceptionable = true) => "string" === typeof input.t && (1 === Object.keys(input).length || Object.keys(input).every(key => {
+    if (["t"].some(prop => key === prop))
+        return true;
+    const value = input[key];
+    if (undefined === value)
+        return true;
+    return false;
+})); const _io3 = (input, _exceptionable = true) => "string" === typeof input.p && (1 === Object.keys(input).length || Object.keys(input).every(key => {
+    if (["p"].some(prop => key === prop))
+        return true;
+    const value = input[key];
+    if (undefined === value)
+        return true;
+    return false;
+})); const _io4 = (input, _exceptionable = true) => "string" === typeof input.d && (1 === Object.keys(input).length || Object.keys(input).every(key => {
+    if (["d"].some(prop => key === prop))
+        return true;
+    const value = input[key];
+    if (undefined === value)
+        return true;
+    return false;
+})); const _io5 = (input, _exceptionable = true) => "string" === typeof input.p && "number" === typeof input.o && (2 === Object.keys(input).length || Object.keys(input).every(key => {
+    if (["p", "o"].some(prop => key === prop))
+        return true;
+    const value = input[key];
+    if (undefined === value)
+        return true;
+    return false;
+})); const _iu0 = (input, _exceptionable = true) => (() => {
+    if (undefined !== input.t)
+        return _io2(input, true && _exceptionable);
+    else if (undefined !== input.p)
+        return _io3(input, true && _exceptionable);
+    else if (undefined !== input.d)
+        return _io4(input, true && _exceptionable);
+    else
+        return false;
+})(); const _ao0 = (input, _path, _exceptionable = true) => (1 === input.v || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+    method: "createAssertEquals",
+    path: _path + ".v",
+    expected: "1",
+    value: input.v
+}, _errorFactory)) && (("object" === typeof input.a && null !== input.a && false === Array.isArray(input.a) || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+    method: "createAssertEquals",
+    path: _path + ".a",
+    expected: "__type",
+    value: input.a
+}, _errorFactory)) && _ao1(input.a, _path + ".a", true && _exceptionable) || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+    method: "createAssertEquals",
+    path: _path + ".a",
+    expected: "__type",
+    value: input.a
+}, _errorFactory)) && (undefined === input.b || ("object" === typeof input.b && null !== input.b || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+    method: "createAssertEquals",
+    path: _path + ".b",
+    expected: "(EncodedAnchorExternalBindingV1 | undefined)",
+    value: input.b
+}, _errorFactory)) && _ao5(input.b, _path + ".b", true && _exceptionable) || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+    method: "createAssertEquals",
+    path: _path + ".b",
+    expected: "(EncodedAnchorExternalBindingV1 | undefined)",
+    value: input.b
+}, _errorFactory)) && (2 === Object.keys(input).length || (false === _exceptionable || Object.keys(input).every(key => {
+    if (["v", "a", "b"].some(prop => key === prop))
+        return true;
+    const value = input[key];
+    if (undefined === value)
+        return true;
+    return __typia_transform__assertGuard._assertGuard(_exceptionable, {
+        method: "createAssertEquals",
+        path: _path + __typia_transform__accessExpressionAsString._accessExpressionAsString(key),
+        expected: "undefined",
+        value: value
+    }, _errorFactory);
+}))); const _ao1 = (input, _path, _exceptionable = true) => false === _exceptionable || Object.keys(input).every(key => {
+    const value = input[key];
+    if (undefined === value)
+        return true;
+    return ("object" === typeof value && null !== value || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+        method: "createAssertEquals",
+        path: _path + __typia_transform__accessExpressionAsString._accessExpressionAsString(key),
+        expected: "(__type.o1 | __type.o2 | __type.o3)",
+        value: value
+    }, _errorFactory)) && _au0(value, _path + __typia_transform__accessExpressionAsString._accessExpressionAsString(key), true && _exceptionable) || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+        method: "createAssertEquals",
+        path: _path + __typia_transform__accessExpressionAsString._accessExpressionAsString(key),
+        expected: "(__type.o1 | __type.o2 | __type.o3)",
+        value: value
+    }, _errorFactory);
+}); const _ao2 = (input, _path, _exceptionable = true) => ("string" === typeof input.t || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+    method: "createAssertEquals",
+    path: _path + ".t",
+    expected: "string",
+    value: input.t
+}, _errorFactory)) && (1 === Object.keys(input).length || (false === _exceptionable || Object.keys(input).every(key => {
+    if (["t"].some(prop => key === prop))
+        return true;
+    const value = input[key];
+    if (undefined === value)
+        return true;
+    return __typia_transform__assertGuard._assertGuard(_exceptionable, {
+        method: "createAssertEquals",
+        path: _path + __typia_transform__accessExpressionAsString._accessExpressionAsString(key),
+        expected: "undefined",
+        value: value
+    }, _errorFactory);
+}))); const _ao3 = (input, _path, _exceptionable = true) => ("string" === typeof input.p || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+    method: "createAssertEquals",
+    path: _path + ".p",
+    expected: "string",
+    value: input.p
+}, _errorFactory)) && (1 === Object.keys(input).length || (false === _exceptionable || Object.keys(input).every(key => {
+    if (["p"].some(prop => key === prop))
+        return true;
+    const value = input[key];
+    if (undefined === value)
+        return true;
+    return __typia_transform__assertGuard._assertGuard(_exceptionable, {
+        method: "createAssertEquals",
+        path: _path + __typia_transform__accessExpressionAsString._accessExpressionAsString(key),
+        expected: "undefined",
+        value: value
+    }, _errorFactory);
+}))); const _ao4 = (input, _path, _exceptionable = true) => ("string" === typeof input.d || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+    method: "createAssertEquals",
+    path: _path + ".d",
+    expected: "string",
+    value: input.d
+}, _errorFactory)) && (1 === Object.keys(input).length || (false === _exceptionable || Object.keys(input).every(key => {
+    if (["d"].some(prop => key === prop))
+        return true;
+    const value = input[key];
+    if (undefined === value)
+        return true;
+    return __typia_transform__assertGuard._assertGuard(_exceptionable, {
+        method: "createAssertEquals",
+        path: _path + __typia_transform__accessExpressionAsString._accessExpressionAsString(key),
+        expected: "undefined",
+        value: value
+    }, _errorFactory);
+}))); const _ao5 = (input, _path, _exceptionable = true) => ("string" === typeof input.p || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+    method: "createAssertEquals",
+    path: _path + ".p",
+    expected: "string",
+    value: input.p
+}, _errorFactory)) && ("number" === typeof input.o || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+    method: "createAssertEquals",
+    path: _path + ".o",
+    expected: "number",
+    value: input.o
+}, _errorFactory)) && (2 === Object.keys(input).length || (false === _exceptionable || Object.keys(input).every(key => {
+    if (["p", "o"].some(prop => key === prop))
+        return true;
+    const value = input[key];
+    if (undefined === value)
+        return true;
+    return __typia_transform__assertGuard._assertGuard(_exceptionable, {
+        method: "createAssertEquals",
+        path: _path + __typia_transform__accessExpressionAsString._accessExpressionAsString(key),
+        expected: "undefined",
+        value: value
+    }, _errorFactory);
+}))); const _au0 = (input, _path, _exceptionable = true) => (() => {
+    if (undefined !== input.t)
+        return _ao2(input, _path, true && _exceptionable);
+    else if (undefined !== input.p)
+        return _ao3(input, _path, true && _exceptionable);
+    else if (undefined !== input.d)
+        return _ao4(input, _path, true && _exceptionable);
+    else
+        return __typia_transform__assertGuard._assertGuard(_exceptionable, {
+            method: "createAssertEquals",
+            path: _path,
+            expected: "(__type.o1 | __type.o2 | __type.o3)",
+            value: input
+        }, _errorFactory);
+})(); const __is = (input, _exceptionable = true) => "object" === typeof input && null !== input && _io0(input, true); let _errorFactory; return (input, errorFactory) => {
+    if (false === __is(input)) {
+        _errorFactory = errorFactory;
+        ((input, _path, _exceptionable = true) => ("object" === typeof input && null !== input || __typia_transform__assertGuard._assertGuard(true, {
+            method: "createAssertEquals",
+            path: _path + "",
+            expected: "EncodedAnchorExternalEnvelopeV1",
+            value: input
+        }, _errorFactory)) && _ao0(input, _path + "", true) || __typia_transform__assertGuard._assertGuard(true, {
+            method: "createAssertEquals",
+            path: _path + "",
+            expected: "EncodedAnchorExternalEnvelopeV1",
+            value: input
+        }, _errorFactory))(input, "$input", true);
+    }
+    return input;
+}; })();
+//# sourceMappingURL=anchor-external.generated.js.map

package/lib/anchor-external.generated.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"anchor-external.generated.js","sourceRoot":"","sources":["../../src/lib/anchor-external.generated.ts"],"names":[],"mappings":";;AAAA,OAAO,EAAE,kBAAkB,EAAE,MAAM,OAAO,CAAC;AAG3C,MAAM,CAAC,MAAM,qCAAqC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OAA6G,CAAC","sourcesContent":["import { createAssertEquals } from 'typia';\nimport type { EncodedAnchorExternalEnvelopeV1 } from './anchor-external.js';\n\nexport const assertEncodedAnchorExternalEnvelopeV1: (input: unknown) => EncodedAnchorExternalEnvelopeV1 = createAssertEquals<EncodedAnchorExternalEnvelopeV1>();\n"]}