@myzonerocks/pact 0.1.0

package/dist/src/policy.js

@@ -0,0 +1,83 @@
+import { Money } from "./money.js";
+function railAllowed(tier, rail) {
+    if (!tier.allowedRails || tier.allowedRails.length === 0)
+        return true;
+    return tier.allowedRails.includes(rail);
+}
+// TieredKyc resolves an identity to its tier and reports the per-payment limit the
+// kernel's router already enforces. Identities with no assigned tier fall to the
+// configured fallback tier.
+export class TieredKyc {
+    assigned;
+    fallback;
+    tiers;
+    constructor(tiers, assigned, fallback) {
+        this.assigned = assigned;
+        this.fallback = fallback;
+        this.tiers = new Map(tiers.map((t) => [t.name, t]));
+    }
+    // tierFor returns the tier governing an identity.
+    tierFor(identity) {
+        const name = this.assigned[identity];
+        if (name !== undefined) {
+            const tier = this.tiers.get(name);
+            if (tier)
+                return tier;
+        }
+        return this.fallback;
+    }
+    async status(identity) {
+        const tier = this.tierFor(identity);
+        return {
+            tier: tier.name,
+            jurisdiction: tier.jurisdiction,
+            limits: tier.perPayment ? { perPayment: tier.perPayment } : {},
+        };
+    }
+}
+// WindowRisk enforces the per-tier rail allow-list and a rolling-window spend
+// cap. It owns its own spend ledger, so the state a compliance decision needs
+// never leaks into the kernel.
+export class WindowRisk {
+    kyc;
+    windowMillis;
+    now;
+    spend = new Map();
+    constructor(kyc, windowMillis, now) {
+        this.kyc = kyc;
+        this.windowMillis = windowMillis;
+        this.now = now;
+    }
+    // evaluate vetoes a payment whose rail the tier forbids, or whose source amount
+    // would push the identity's spend over the window cap. An allowed payment is
+    // recorded so it counts against the window for the next one.
+    evaluate(identity, _intent, quote) {
+        const tier = this.kyc.tierFor(identity);
+        if (!railAllowed(tier, quote.payInRail) || !railAllowed(tier, quote.payOutRail)) {
+            return { allow: false, reason: "rail not permitted for this tier" };
+        }
+        if (!tier.windowSpend) {
+            return { allow: true, reason: "" };
+        }
+        const now = this.now();
+        const horizon = now - this.windowMillis;
+        const kept = (this.spend.get(identity) ?? []).filter((e) => e.atMillis > horizon);
+        let total = Money.create(tier.windowSpend.currency, tier.windowSpend.exponent, 0n);
+        try {
+            for (const e of kept)
+                total = total.add(e.amount);
+            const projected = total.add(quote.srcAmount);
+            if (projected.cmp(tier.windowSpend) > 0) {
+                this.spend.set(identity, kept);
+                return { allow: false, reason: "payment exceeds the rolling spend limit" };
+            }
+        }
+        catch {
+            this.spend.set(identity, kept);
+            return { allow: false, reason: "payment currency differs from the window cap" };
+        }
+        kept.push({ atMillis: now, amount: quote.srcAmount });
+        this.spend.set(identity, kept);
+        return { allow: true, reason: "" };
+    }
+}

package/dist/src/protocol.d.ts

@@ -0,0 +1,4 @@
+export declare const ID = "pact";
+export declare const VERSION = "1";
+export declare function domain(kind: string): string;
+export declare const DEFAULT_SKEW_MILLIS = 120000;

package/dist/src/protocol.js

@@ -0,0 +1,15 @@
+// ID is the stable protocol identifier. It is a technical constant, not a brand:
+// it appears only inside domain-separation tags and is never localized or
+// rebranded. Changing it is a breaking wire migration.
+export const ID = "pact";
+// VERSION is the wire version. It composes with ID into the domain prefix every
+// signed preimage begins with.
+export const VERSION = "1";
+const domainPrefix = `${ID}/${VERSION}/`;
+// domain builds the full domain tag for a message kind, e.g. "pact/1/intent".
+export function domain(kind) {
+    return domainPrefix + kind;
+}
+// DEFAULT_SKEW_MILLIS is the tolerated clock difference when deciding whether an
+// intent or quote has expired.
+export const DEFAULT_SKEW_MILLIS = 120_000;

package/dist/src/router.d.ts

@@ -0,0 +1,16 @@
+import type { Quote } from "./message.js";
+import type { KycStatus } from "./compliance.js";
+export declare enum PolicyKind {
+    Cheapest = 0,
+    Fastest = 1,
+    PreferredRail = 2
+}
+export interface Policy {
+    kind: PolicyKind;
+    preferredRails?: string[];
+}
+export declare class NoQuoteError extends Error {
+    constructor(reason: string);
+}
+export declare function isExpired(deadline: number, now: number, skew: number): boolean;
+export declare function route(quotes: Quote[], policy: Policy, kyc: KycStatus, now: number, skew: number): Quote;

package/dist/src/router.js

@@ -0,0 +1,87 @@
+import { withinLimits } from "./compliance.js";
+// PolicyKind names how the router chooses among competing quotes.
+export var PolicyKind;
+(function (PolicyKind) {
+    PolicyKind[PolicyKind["Cheapest"] = 0] = "Cheapest";
+    PolicyKind[PolicyKind["Fastest"] = 1] = "Fastest";
+    PolicyKind[PolicyKind["PreferredRail"] = 2] = "PreferredRail";
+})(PolicyKind || (PolicyKind = {}));
+export class NoQuoteError extends Error {
+    constructor(reason) {
+        super(`pact: no eligible quote: ${reason}`);
+        this.name = "NoQuoteError";
+    }
+}
+export function isExpired(deadline, now, skew) {
+    if (deadline === 0)
+        return false;
+    return deadline + skew <= now;
+}
+// route selects one quote deterministically. It first discards quotes that are
+// expired against now or that exceed the identity's KYC limit, then ranks the
+// survivors by the policy. Ties break by pay-in adapter, then pay-out adapter,
+// then quote id, so the choice is total and stable and never depends on input
+// order or randomness.
+export function route(quotes, policy, kyc, now, skew) {
+    const eligible = quotes.filter((q) => !isExpired(q.expiresAt, now, skew) && withinLimits(kyc, q));
+    if (eligible.length === 0) {
+        throw new NoQuoteError("all quotes expired or over limit");
+    }
+    const rank = rankFn(policy);
+    eligible.sort((a, b) => {
+        const primary = rank(a, b);
+        if (primary !== 0)
+            return primary;
+        if (a.payInAdapterId !== b.payInAdapterId)
+            return a.payInAdapterId < b.payInAdapterId ? -1 : 1;
+        if (a.payOutAdapterId !== b.payOutAdapterId)
+            return a.payOutAdapterId < b.payOutAdapterId ? -1 : 1;
+        if (a.id !== b.id)
+            return a.id < b.id ? -1 : 1;
+        return 0;
+    });
+    return eligible[0];
+}
+function rankFn(policy) {
+    switch (policy.kind) {
+        case PolicyKind.Fastest:
+            return (a, b) => cmpNumber(a.latencyEstimateMs, b.latencyEstimateMs);
+        case PolicyKind.PreferredRail: {
+            const rank = railRank(policy.preferredRails ?? []);
+            return (a, b) => {
+                const byRail = cmpNumber(rank(a.payOutRail), rank(b.payOutRail));
+                return byRail !== 0 ? byRail : cmpMoney(a, b);
+            };
+        }
+        default:
+            return (a, b) => {
+                const bySrc = cmpMoney(a, b);
+                if (bySrc !== 0)
+                    return bySrc;
+                return safeCmp(a.fees, b.fees);
+            };
+    }
+}
+function railRank(preferred) {
+    const index = new Map();
+    preferred.forEach((rail, i) => index.set(rail, i));
+    const unranked = preferred.length;
+    return (rail) => index.get(rail) ?? unranked;
+}
+function cmpNumber(a, b) {
+    return a < b ? -1 : a > b ? 1 : 0;
+}
+// cmpMoney orders two quotes by source amount. Amounts in different currencies
+// are treated as incomparable and reported equal, deferring to the tie-break so
+// the router never throws on a mixed-currency quote set.
+function cmpMoney(a, b) {
+    return safeCmp(a.srcAmount, b.srcAmount);
+}
+function safeCmp(a, b) {
+    try {
+        return a.cmp(b);
+    }
+    catch {
+        return 0;
+    }
+}

package/dist/src/signing.d.ts

@@ -0,0 +1,27 @@
+import type { Intent, Quote, Authorization } from "./message.js";
+export interface Signer {
+    identity(): string;
+    sign(preimage: Uint8Array): Uint8Array;
+}
+export interface Verifier {
+    verify(identity: string, preimage: Uint8Array, signature: Uint8Array): boolean;
+}
+export declare class BadSignatureError extends Error {
+    constructor();
+}
+export declare function authorize(intent: Intent, quote: Quote, signer: Signer, signedAt: number): Authorization;
+export declare function verifyAuthorization(auth: Authorization, intent: Intent, quote: Quote, verifier: Verifier): void;
+export declare class Ed25519Signer implements Signer {
+    private readonly id;
+    private readonly privateKey;
+    readonly publicKey: Uint8Array;
+    private constructor();
+    static fromSeed(identity: string, seed: Uint8Array): Ed25519Signer;
+    identity(): string;
+    sign(preimage: Uint8Array): Uint8Array;
+}
+export declare class Ed25519Verifier implements Verifier {
+    private readonly keys;
+    constructor(keys: Map<string, Uint8Array>);
+    verify(identity: string, preimage: Uint8Array, signature: Uint8Array): boolean;
+}

package/dist/src/signing.js

@@ -0,0 +1,72 @@
+import { intentHash, quoteHash, signingPreimage } from "./message.js";
+import { ed25519KeyFromSeed, ed25519Sign, ed25519Verify } from "./crypto.js";
+export class BadSignatureError extends Error {
+    constructor() {
+        super("pact: signature does not verify");
+        this.name = "BadSignatureError";
+    }
+}
+// authorize builds and signs an authorization committing a sender to one quote
+// for one intent.
+export function authorize(intent, quote, signer, signedAt) {
+    if (quote.intentId !== intent.id) {
+        throw new Error("pact: quote does not belong to intent");
+    }
+    const preimage = signingPreimage(intentHash(intent), quoteHash(quote), signer.identity(), signedAt);
+    return {
+        intentId: intent.id,
+        quoteId: quote.id,
+        signerIdentity: signer.identity(),
+        signedAt,
+        signature: signer.sign(preimage),
+    };
+}
+// verifyAuthorization checks that an authorization was signed for exactly this
+// intent and quote. Binding both hashes into the preimage makes a captured
+// signature useless against any other intent or quote.
+export function verifyAuthorization(auth, intent, quote, verifier) {
+    if (auth.intentId !== intent.id || auth.quoteId !== quote.id || quote.intentId !== intent.id) {
+        throw new Error("pact: authorization does not match intent and quote");
+    }
+    const preimage = signingPreimage(intentHash(intent), quoteHash(quote), auth.signerIdentity, auth.signedAt);
+    if (!verifier.verify(auth.signerIdentity, preimage, auth.signature)) {
+        throw new BadSignatureError();
+    }
+}
+// Ed25519Signer is the reference signer used by the shared test vectors and by
+// hosts whose identity key is an Ed25519 key. Hosts that sign with a
+// smart-account validator supply their own Signer instead.
+export class Ed25519Signer {
+    id;
+    privateKey;
+    publicKey;
+    constructor(id, privateKey, publicKey) {
+        this.id = id;
+        this.privateKey = privateKey;
+        this.publicKey = publicKey;
+    }
+    static fromSeed(identity, seed) {
+        const { privateKey, publicKey } = ed25519KeyFromSeed(seed);
+        return new Ed25519Signer(identity, privateKey, publicKey);
+    }
+    identity() {
+        return this.id;
+    }
+    sign(preimage) {
+        return ed25519Sign(this.privateKey, preimage);
+    }
+}
+// Ed25519Verifier resolves an identity string to its Ed25519 public key. A real
+// host resolves keys from its own key directory instead of a map.
+export class Ed25519Verifier {
+    keys;
+    constructor(keys) {
+        this.keys = keys;
+    }
+    verify(identity, preimage, signature) {
+        const pub = this.keys.get(identity);
+        if (!pub)
+            return false;
+        return ed25519Verify(pub, preimage, signature);
+    }
+}

package/dist/src/state.d.ts

@@ -0,0 +1,23 @@
+export declare enum State {
+    Unspecified = 0,
+    Draft = 1,
+    Quoted = 2,
+    Authorized = 3,
+    Submitted = 4,
+    Settled = 5,
+    Failed = 6,
+    Expired = 7,
+    Refunded = 8,
+    Collecting = 9,
+    Held = 10,
+    Disbursing = 11,
+    Refunding = 12
+}
+export declare const stateName: Record<State, string>;
+export declare function canTransition(from: State, to: State): boolean;
+export declare function isTerminal(state: State): boolean;
+export declare class TransitionError extends Error {
+    readonly from: State;
+    readonly to: State;
+    constructor(from: State, to: State);
+}

package/dist/src/state.js

@@ -0,0 +1,76 @@
+// State is a stage in a payment's lifecycle. The unspecified value is
+// intentionally invalid so an uninitialized state never passes for a real one.
+export var State;
+(function (State) {
+    State[State["Unspecified"] = 0] = "Unspecified";
+    State[State["Draft"] = 1] = "Draft";
+    State[State["Quoted"] = 2] = "Quoted";
+    State[State["Authorized"] = 3] = "Authorized";
+    State[State["Submitted"] = 4] = "Submitted";
+    State[State["Settled"] = 5] = "Settled";
+    State[State["Failed"] = 6] = "Failed";
+    State[State["Expired"] = 7] = "Expired";
+    State[State["Refunded"] = 8] = "Refunded";
+    // The states below carry a bridged corridor through its escrow middle, where
+    // the pay-in and pay-out are different providers or currencies.
+    State[State["Collecting"] = 9] = "Collecting";
+    State[State["Held"] = 10] = "Held";
+    State[State["Disbursing"] = 11] = "Disbursing";
+    State[State["Refunding"] = 12] = "Refunding";
+})(State || (State = {}));
+// stateName maps each state to the lowercase token used in canonical preimages
+// and on the wire. These strings are signed material and must not change for a
+// given wire version.
+export const stateName = {
+    [State.Unspecified]: "unspecified",
+    [State.Draft]: "draft",
+    [State.Quoted]: "quoted",
+    [State.Authorized]: "authorized",
+    [State.Submitted]: "submitted",
+    [State.Settled]: "settled",
+    [State.Failed]: "failed",
+    [State.Expired]: "expired",
+    [State.Refunded]: "refunded",
+    [State.Collecting]: "collecting",
+    [State.Held]: "held",
+    [State.Disbursing]: "disbursing",
+    [State.Refunding]: "refunding",
+};
+// transitions is the whole state machine expressed as data. A payment may move
+// from a key only to a listed state; every other pairing is illegal. Terminal
+// states map to an empty set. A direct corridor settles in one phase; a bridged
+// one enters the escrow middle at collecting and unwinds through refunding when
+// its pay-out cannot complete.
+const transitions = {
+    [State.Unspecified]: new Set([State.Draft]),
+    [State.Draft]: new Set([State.Quoted, State.Expired]),
+    [State.Quoted]: new Set([State.Authorized, State.Expired]),
+    [State.Authorized]: new Set([State.Submitted, State.Collecting, State.Expired]),
+    [State.Submitted]: new Set([State.Settled, State.Failed]),
+    [State.Collecting]: new Set([State.Held, State.Failed, State.Expired]),
+    [State.Held]: new Set([State.Disbursing, State.Refunding, State.Expired]),
+    [State.Disbursing]: new Set([State.Settled, State.Failed, State.Refunding]),
+    [State.Refunding]: new Set([State.Refunded, State.Failed]),
+    [State.Settled]: new Set([State.Refunded]),
+    [State.Failed]: new Set(),
+    [State.Expired]: new Set(),
+    [State.Refunded]: new Set(),
+};
+export function canTransition(from, to) {
+    return transitions[from].has(to);
+}
+// isTerminal reports whether a state accepts no further transition. Settled is
+// not terminal because it still admits the single edge to refunded.
+export function isTerminal(state) {
+    return transitions[state].size === 0;
+}
+export class TransitionError extends Error {
+    from;
+    to;
+    constructor(from, to) {
+        super(`pact: illegal transition ${stateName[from]} -> ${stateName[to]}`);
+        this.from = from;
+        this.to = to;
+        this.name = "TransitionError";
+    }
+}

package/dist/src/wire.d.ts

@@ -0,0 +1,30 @@
+import type { Intent, Quote, Authorization, Settlement } from "./message.js";
+export declare enum WireKind {
+    Intent = 1,
+    Quote = 2,
+    Authorization = 3,
+    Settlement = 4
+}
+export declare function encodeIntent(i: Intent): Uint8Array;
+export declare function encodeQuote(q: Quote): Uint8Array;
+export declare function encodeAuthorization(a: Authorization): Uint8Array;
+export declare function encodeSettlement(s: Settlement): Uint8Array;
+export type WireMessage = {
+    kind: WireKind.Intent;
+    message: Intent;
+} | {
+    kind: WireKind.Quote;
+    message: Quote;
+} | {
+    kind: WireKind.Authorization;
+    message: Authorization;
+} | {
+    kind: WireKind.Settlement;
+    message: Settlement;
+};
+export declare function encodeMessage(msg: WireMessage): Uint8Array;
+export declare function decodeMessage(frame: Uint8Array): WireMessage;
+export declare function decodeIntent(b: Uint8Array): Intent;
+export declare function decodeQuote(b: Uint8Array): Quote;
+export declare function decodeAuthorization(b: Uint8Array): Authorization;
+export declare function decodeSettlement(b: Uint8Array): Settlement;

package/dist/src/wire.js

@@ -0,0 +1,221 @@
+import { Money } from "./money.js";
+import { CanonicalWriter } from "./canonical.js";
+// The wire codec serializes messages for transport. It is distinct from the
+// canonical signing preimage: signing binds a fixed subset of fields under a
+// domain tag, while the wire form carries every field so a peer can reconstruct
+// the message. Both use the same length-delimited primitives; a message's wire
+// bytes are never signed and its signing preimage is never sent.
+export var WireKind;
+(function (WireKind) {
+    WireKind[WireKind["Intent"] = 1] = "Intent";
+    WireKind[WireKind["Quote"] = 2] = "Quote";
+    WireKind[WireKind["Authorization"] = 3] = "Authorization";
+    WireKind[WireKind["Settlement"] = 4] = "Settlement";
+})(WireKind || (WireKind = {}));
+const decoder = new TextDecoder();
+export function encodeIntent(i) {
+    return new CanonicalWriter()
+        .str(i.id)
+        .str(i.senderRef)
+        .str(i.recipientRef)
+        .money(i.amount)
+        .str(i.memo)
+        .u64(i.expiresAt)
+        .list(i.allowedRails)
+        .stringMap(i.metadata)
+        .preimage();
+}
+export function encodeQuote(q) {
+    return new CanonicalWriter()
+        .str(q.id)
+        .str(q.intentId)
+        .str(q.payInAdapterId)
+        .str(q.payInRail)
+        .str(q.payOutAdapterId)
+        .str(q.payOutRail)
+        .str(q.bridgeId)
+        .money(q.srcAmount)
+        .money(q.dstAmount)
+        .money(q.fees)
+        .str(q.fxRate)
+        .u64(q.expiresAt)
+        .str(q.providerQuoteRef)
+        .u64(q.latencyEstimateMs)
+        .preimage();
+}
+export function encodeAuthorization(a) {
+    return new CanonicalWriter()
+        .str(a.intentId)
+        .str(a.quoteId)
+        .str(a.signerIdentity)
+        .u64(a.signedAt)
+        .bytes(a.signature)
+        .preimage();
+}
+export function encodeSettlement(s) {
+    return new CanonicalWriter()
+        .str(s.intentId)
+        .u64(s.state)
+        .str(s.adapterId)
+        .str(s.providerTxRef)
+        .str(s.onchainTxHash)
+        .bytes(s.receiptHash)
+        .str(s.reason)
+        .u64(s.settledAt)
+        .preimage();
+}
+export function encodeMessage(msg) {
+    const payload = msg.kind === WireKind.Intent
+        ? encodeIntent(msg.message)
+        : msg.kind === WireKind.Quote
+            ? encodeQuote(msg.message)
+            : msg.kind === WireKind.Authorization
+                ? encodeAuthorization(msg.message)
+                : encodeSettlement(msg.message);
+    const out = new Uint8Array(payload.length + 1);
+    out[0] = msg.kind;
+    out.set(payload, 1);
+    return out;
+}
+export function decodeMessage(frame) {
+    if (frame.length === 0) {
+        throw new Error("pact: wire frame ended mid-field");
+    }
+    const kind = frame[0];
+    const body = frame.subarray(1);
+    switch (kind) {
+        case WireKind.Intent:
+            return { kind, message: decodeIntent(body) };
+        case WireKind.Quote:
+            return { kind, message: decodeQuote(body) };
+        case WireKind.Authorization:
+            return { kind, message: decodeAuthorization(body) };
+        case WireKind.Settlement:
+            return { kind, message: decodeSettlement(body) };
+        default:
+            throw new Error(`pact: unknown wire kind ${kind}`);
+    }
+}
+// WireReader consumes the length-delimited primitives in order.
+class WireReader {
+    buf;
+    pos = 0;
+    constructor(buf) {
+        this.buf = buf;
+    }
+    bytes() {
+        if (this.pos + 4 > this.buf.length) {
+            throw new Error("pact: wire frame ended mid-field");
+        }
+        const view = new DataView(this.buf.buffer, this.buf.byteOffset + this.pos, 4);
+        const length = view.getUint32(0, false);
+        this.pos += 4;
+        if (this.pos + length > this.buf.length) {
+            throw new Error("pact: wire frame ended mid-field");
+        }
+        const out = this.buf.subarray(this.pos, this.pos + length);
+        this.pos += length;
+        return out;
+    }
+    str() {
+        return decoder.decode(this.bytes());
+    }
+    u64() {
+        if (this.pos + 8 > this.buf.length) {
+            throw new Error("pact: wire frame ended mid-field");
+        }
+        const view = new DataView(this.buf.buffer, this.buf.byteOffset + this.pos, 8);
+        this.pos += 8;
+        return Number(view.getBigUint64(0, false));
+    }
+    money() {
+        const minor = this.str();
+        const currency = this.str();
+        const exponent = this.u64();
+        return Money.parse(currency, exponent, minor);
+    }
+    list() {
+        const count = this.u64();
+        const out = [];
+        for (let i = 0; i < count; i++)
+            out.push(this.str());
+        return out;
+    }
+    stringMap() {
+        const count = this.u64();
+        const out = {};
+        for (let i = 0; i < count; i++) {
+            const key = this.str();
+            out[key] = this.str();
+        }
+        return out;
+    }
+    requireDone() {
+        if (this.pos !== this.buf.length) {
+            throw new Error("pact: trailing bytes after wire frame");
+        }
+    }
+}
+export function decodeIntent(b) {
+    const r = new WireReader(b);
+    const intent = {
+        id: r.str(),
+        senderRef: r.str(),
+        recipientRef: r.str(),
+        amount: r.money(),
+        memo: r.str(),
+        expiresAt: r.u64(),
+        allowedRails: r.list(),
+        metadata: r.stringMap(),
+    };
+    r.requireDone();
+    return intent;
+}
+export function decodeQuote(b) {
+    const r = new WireReader(b);
+    const quote = {
+        id: r.str(),
+        intentId: r.str(),
+        payInAdapterId: r.str(),
+        payInRail: r.str(),
+        payOutAdapterId: r.str(),
+        payOutRail: r.str(),
+        bridgeId: r.str(),
+        srcAmount: r.money(),
+        dstAmount: r.money(),
+        fees: r.money(),
+        fxRate: r.str(),
+        expiresAt: r.u64(),
+        providerQuoteRef: r.str(),
+        latencyEstimateMs: r.u64(),
+    };
+    r.requireDone();
+    return quote;
+}
+export function decodeAuthorization(b) {
+    const r = new WireReader(b);
+    const auth = {
+        intentId: r.str(),
+        quoteId: r.str(),
+        signerIdentity: r.str(),
+        signedAt: r.u64(),
+        signature: r.bytes().slice(),
+    };
+    r.requireDone();
+    return auth;
+}
+export function decodeSettlement(b) {
+    const r = new WireReader(b);
+    const settlement = {
+        intentId: r.str(),
+        state: r.u64(),
+        adapterId: r.str(),
+        providerTxRef: r.str(),
+        onchainTxHash: r.str(),
+        receiptHash: r.bytes().slice(),
+        reason: r.str(),
+        settledAt: r.u64(),
+    };
+    r.requireDone();
+    return settlement;
+}

package/dist/test/erc20.test.d.ts

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