remesso-sdk 0.0.0-stage → 0.2.0

package/dist/requests.js

@@ -0,0 +1,145 @@
+import { checksum, findToken } from "./deployment.js";
+import { RemessoError } from "./errors.js";
+import { declineTypedData, MAX_DECLINE_TTL_SECS } from "./vendor/request-decline.js";
+export function makeRequests(ctx, deps) {
+    const call = (body) => ctx.post(ctx.endpoints.requestPayment, body);
+    async function get(id) {
+        return await call({ action: "status", id: uuid(id) });
+    }
+    return {
+        get,
+        /// Ask `payer` to pay you. Free. Returns the request and the link that
+        /// opens their form prefilled.
+        async create(input) {
+            const to = input.to ? checksum(input.to) : ctx.account?.address;
+            if (!to)
+                throw new RemessoError("invalid", "to is required without an account: where you want to be paid");
+            if (input.token && !findToken(input.token))
+                throw new RemessoError("invalid", `unknown token ${input.token}`);
+            const out = await call({
+                payer: checksum(input.payer),
+                to,
+                amount: input.amount,
+                token: input.token ? findToken(input.token).symbol : undefined,
+                every: input.every,
+                runs: input.runs,
+                from: input.from,
+                note: input.note,
+            });
+            return { ...out, reference: out.id.replace(/-/g, "") };
+        },
+        /// The live requests addressed to `payer` (default: this account):
+        /// pending and under 30 days old.
+        async list(payer) {
+            const who = payer ? checksum(payer) : ctx.requireAccount().address;
+            return (await call({ action: "list", payer: who })).requests;
+        },
+        /// Report the schedule that answers a request. It binds only if it is
+        /// from the wallet asked, pays the address that asked, was created after
+        /// the request, and answers no other request.
+        ///
+        /// Seconds after a schedule lands the backend may not see it yet: its
+        /// indexer runs every minute, and a node behind forno's load balancer can
+        /// answer from an earlier block. It says so and asks to be tried again,
+        /// which this does for up to `waitMs` (default 90s), as it does after a
+        /// server error: answering twice with the same schedule is safe, the
+        /// backend gives the first answer again.
+        async answer(id, scheduleId, contract, opts = {}) {
+            const until = Date.now() + (opts.waitMs ?? 90_000);
+            for (let wait = 3_000;; wait = Math.min(wait * 2, 15_000)) {
+                try {
+                    const out = await call({
+                        action: "answer",
+                        id: uuid(id),
+                        schedule: String(scheduleId),
+                        ...(contract ? { contract: checksum(contract) } : {}),
+                    });
+                    return { status: out.status, signed: out.signed };
+                }
+                catch (e) {
+                    const unseen = e instanceof RemessoError && e.code === "conflict" && /hasn't been seen on-chain yet/.test(e.message);
+                    const serverError = e instanceof RemessoError && e.code === "http" && Number(e.details?.status) >= 500;
+                    if (!(unseen || serverError) || Date.now() + wait > until)
+                        throw e;
+                    await new Promise((res) => setTimeout(res, wait));
+                }
+            }
+        },
+        /// Turn a request down, for everyone: signed by the wallet it was sent
+        /// to, or by an agent under a live policy from that wallet (`policyId`).
+        async decline(id, opts = {}) {
+            const account = ctx.requireAccount();
+            if (!ctx.wallet)
+                throw new RemessoError("no_account", "declining needs an account that can sign");
+            const rid = uuid(id);
+            const ttl = Math.min(Math.max(opts.ttlSeconds ?? 600, 60), MAX_DECLINE_TTL_SECS);
+            const expiry = Math.floor(Date.now() / 1000) + ttl;
+            const signature = await ctx.wallet.signTypedData({ account, ...declineTypedData(rid, expiry) });
+            return await call({
+                action: "decline",
+                id: rid,
+                expiry,
+                signature,
+                ...(opts.policyId != null ? { agent: account.address, policy_id: String(opts.policyId) } : {}),
+            });
+        },
+        /// Pay a request through a policy, as an agent. The payment carries the
+        /// request's reference, so the requester sees it answered, and the
+        /// request id is the default idempotency key: one payment per request.
+        async pay(id, opts = {}) {
+            const r = await get(id);
+            if (!["pending", "accepted", "accepted_with_changes"].includes(r.status)) {
+                throw new RemessoError("refused", `request ${r.id} is ${r.status}, so it isn't paid`);
+            }
+            const amount = opts.amount ?? r.requested.amount;
+            if (!amount)
+                throw new RemessoError("invalid", `request ${r.id} names no amount, so pass one`);
+            const token = r.requested.token ?? "USDT";
+            // A request is addressed to one wallet. Paying someone else's from this
+            // person's wallet answers nothing.
+            const policyIds = opts.policyId != null ? [BigInt(opts.policyId)] : await deps.policies.find();
+            const mine = [];
+            for (const pid of policyIds) {
+                const p = await deps.policies.get(pid);
+                if (p.active && p.owner.toLowerCase() === r.payer.toLowerCase() && p.symbol === findToken(token)?.symbol)
+                    mine.push(p);
+            }
+            if (!mine.length) {
+                throw new RemessoError("refused", `request ${r.id} was sent to ${r.payer}, and no active ${token} policy from that wallet names this agent`);
+            }
+            return await deps.pay({
+                ...opts,
+                to: r.requested.to,
+                amount,
+                token,
+                memo: r.reference,
+                policyId: opts.policyId ?? mine[0].id,
+                idempotencyKey: opts.idempotencyKey ?? `request:${r.id}`,
+            });
+        },
+        /// Wait until a request is paid: a payment with a transaction, not an
+        /// answer. Polls `status`.
+        async waitUntilPaid(id, opts = {}) {
+            const until = Date.now() + (opts.timeoutMs ?? 20 * 60_000);
+            for (;;) {
+                const r = await get(id);
+                if (r.payment?.state === "paid")
+                    return r;
+                if (r.status === "declined" || r.status === "expired")
+                    throw new RemessoError("refused", `request ${r.id} is ${r.status}`);
+                if (Date.now() > until)
+                    throw new RemessoError("timeout", `request ${r.id} isn't paid yet (${r.status})`);
+                if (opts.signal?.aborted)
+                    throw new RemessoError("timeout", "stopped");
+                await new Promise((res) => setTimeout(res, opts.intervalMs ?? 15_000));
+            }
+        },
+    };
+}
+const UUID = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
+function uuid(id) {
+    const s = String(id).trim().toLowerCase();
+    if (!UUID.test(s))
+        throw new RemessoError("invalid", `not a payment request id: ${id}`);
+    return s;
+}

package/dist/schedules.d.ts

@@ -0,0 +1,111 @@
+import { type Address, type Hex, type Log } from "viem";
+import { type Ctx } from "./context.js";
+import { type Token } from "./deployment.js";
+import type { RequestStatus } from "./requests.js";
+export declare const CADENCES: {
+    readonly week: number;
+    readonly fortnight: number;
+    readonly month: number;
+    readonly quarter: number;
+};
+export type Cadence = keyof typeof CADENCES;
+export type CreateScheduleInput = {
+    /** Who gets paid. With `request`, the request's own address. */
+    to?: string;
+    /** Per payment, what leaves your wallet, as a decimal string: "1.50". Use this or `receive`. */
+    amount?: string;
+    /** Per payment, what the recipient receives after Remesso's fee. The SDK works out what to send. */
+    receive?: string;
+    /** Symbol or address. Default USDT, or the request's token. */
+    token?: string;
+    /** week | fortnight | month | quarter, or seconds (at least an hour). Default week, or the request's. */
+    every?: Cadence | number;
+    /** How many payments. With `request`, defaults to the request's. */
+    runs?: number;
+    /** When the first payment is due. Default now: it goes out within minutes. */
+    firstRunAt?: Date;
+    /**
+     * Who may bring a payment forward: "remesso" for Remesso's executor (whoever it is
+     * at the time), or an address. Same recipient, same amount, never an extra payment.
+     * Default nobody.
+     */
+    trigger?: "remesso" | string | null;
+    /** How many early sends the trigger may make. Default: all of them. */
+    triggers?: number;
+    /** A payment request this schedule answers. Its terms fill whatever you leave out. */
+    request?: string;
+    /**
+     * Approve the contract for this schedule's total on top of what is already
+     * approved (the default), or not at all when you manage approvals yourself.
+     */
+    approve?: boolean;
+};
+export type CreatedSchedule = {
+    id: bigint;
+    hash: Hex;
+    approveHash: Hex | null;
+    to: Address;
+    token: Token["symbol"];
+    /** What leaves the payer's wallet each payment, in base units. */
+    amountIn: bigint;
+    /** What the recipient receives each payment, in base units, after the fee. */
+    recipientGets: bigint;
+    feeBps: number;
+    runs: number;
+    intervalSeconds: number;
+    firstRunAt: Date;
+    expiresAt: Date;
+    /** With `request`: how the request took the answer, or why it didn't. */
+    request?: {
+        status: string;
+        signed: unknown;
+    } | {
+        error: string;
+    };
+    warnings: string[];
+};
+export type Schedule = {
+    id: bigint;
+    sender: Address;
+    to: Address;
+    token: Address;
+    amountIn: bigint;
+    recipientGets: bigint;
+    feeBps: number;
+    intervalSeconds: number;
+    maxRuns: number;
+    runsExecuted: number;
+    nextRunAt: Date;
+    lastRunAt: Date | null;
+    expiresAt: Date;
+    active: boolean;
+    cancelled: boolean;
+    payoutType: number;
+    trigger: Address;
+    triggersLeft: number;
+};
+type Deps = {
+    getRequest(id: string): Promise<RequestStatus>;
+    answer(id: string, scheduleId: bigint): Promise<{
+        status: string;
+        signed: unknown;
+    }>;
+};
+export declare function makeSchedules(ctx: Ctx, deps: Deps): {
+    create: (input: CreateScheduleInput) => Promise<CreatedSchedule>;
+    get: (id: bigint | number | string) => Promise<Schedule>;
+    status(id: bigint | number | string): Promise<{
+        due: boolean;
+        funded: boolean;
+        approved: boolean;
+        nextRunAt: Date;
+    }>;
+    list(sender?: string): Promise<bigint[]>;
+    cancel(id: bigint | number | string): Promise<Hex>;
+    setActive(id: bigint | number | string, active: boolean): Promise<Hex>;
+    setTrigger(id: bigint | number | string, trigger: "remesso" | string | null, triggers?: number): Promise<Hex>;
+};
+export type Schedules = ReturnType<typeof makeSchedules>;
+export declare function scheduleIdFrom(logs: readonly Log[]): bigint | null;
+export declare function intervalOf(every: Cadence | number | string): number;
+export {};

package/dist/schedules.js

@@ -0,0 +1,232 @@
+/// Schedules: a payer signs once, on-chain, a fixed amount to a fixed address
+/// on a fixed cadence, and Remesso's executor sends each payment when it is
+/// due. After signing, nothing can change the recipient, the amount or the
+/// cadence: not Remesso, not the contract's owner, not the payer. Cancelling
+/// is the only edit. Extracted from `examples/create-schedule.ts`.
+import { parseEventLogs, zeroAddress } from "viem";
+import { erc20Abi, executorAbi } from "./abi.js";
+import { untilVisible, write } from "./context.js";
+import { checksum, CURRENT_EXECUTOR, EXECUTOR, findToken, formatAmount, runLimits, token as tokenOf, toUnits, } from "./deployment.js";
+import { RemessoError } from "./errors.js";
+import { grossFor, netOf } from "./vendor/fee.js";
+export const CADENCES = {
+    week: 7 * 86_400,
+    fortnight: 14 * 86_400,
+    month: 30 * 86_400,
+    quarter: 90 * 86_400,
+};
+/// Direct: the recipient receives the token the payer funds, with no swap.
+const DIRECT = 2;
+export function makeSchedules(ctx, deps) {
+    const read = (functionName, args = []) => ctx.pub.readContract({ address: EXECUTOR, abi: executorAbi, functionName, args });
+    /// The schedule's token, so a sender holding no CELO can pay for managing
+    /// it in that token, as they could for creating it.
+    const gasTokenOf = async (id) => findToken((await get(id)).token) ?? null;
+    async function get(id) {
+        const s = await untilVisible(() => read("getSchedule", [BigInt(id)]), (v) => v.sender !== zeroAddress);
+        if (s.sender === zeroAddress)
+            throw new RemessoError("not_found", `there is no schedule ${id} on ${EXECUTOR}`);
+        return {
+            id: BigInt(id),
+            sender: s.sender,
+            to: s.destination,
+            token: s.token,
+            amountIn: s.amountIn,
+            recipientGets: netOf(s.amountIn, s.feeBps),
+            feeBps: s.feeBps,
+            intervalSeconds: Number(s.interval),
+            maxRuns: s.maxRuns,
+            runsExecuted: s.runsExecuted,
+            nextRunAt: new Date(Number(s.nextRunAt) * 1000),
+            lastRunAt: s.lastRunAt ? new Date(Number(s.lastRunAt) * 1000) : null,
+            expiresAt: new Date(Number(s.expiresAt) * 1000),
+            active: s.active,
+            cancelled: s.cancelled,
+            payoutType: s.payoutType,
+            trigger: s.trigger,
+            triggersLeft: s.triggersLeft,
+        };
+    }
+    async function create(input) {
+        const account = ctx.requireAccount();
+        await ctx.assertChain();
+        const me = account.address.toLowerCase();
+        const warnings = [];
+        // A request's terms fill whatever was left out. It must be addressed to
+        // this wallet: paying someone else's request answers nothing, and it is
+        // what an injected instruction would ask for.
+        let req = null;
+        let { to, amount, receive, token: tokenIn, every, runs } = input;
+        if (input.request) {
+            req = await deps.getRequest(input.request);
+            if (req.payer.toLowerCase() !== me) {
+                throw new RemessoError("refused", `request ${req.id} was sent to ${req.payer}, not to ${account.address}`);
+            }
+            if (req.status !== "pending")
+                throw new RemessoError("refused", `request ${req.id} is ${req.status}, so there is nothing to answer`);
+            if (to && to.toLowerCase() !== req.requested.to.toLowerCase()) {
+                throw new RemessoError("refused", `request ${req.id} asks to be paid at ${req.requested.to}, not ${to}`);
+            }
+            to = req.requested.to;
+            tokenIn ??= req.requested.token ?? undefined;
+            every ??= req.requested.intervalSeconds ?? undefined;
+            runs ??= req.requested.runs ?? undefined;
+            if (amount == null && receive == null && req.requested.amount)
+                receive = req.requested.amount;
+        }
+        if (!to)
+            throw new RemessoError("invalid", "to is required: who gets paid");
+        const dest = checksum(to);
+        if (dest.toLowerCase() === me)
+            throw new RemessoError("invalid", "to is this wallet: a schedule paying itself only loses the fee");
+        const t = tokenOf(tokenIn ?? "USDT");
+        const interval = intervalOf(every ?? "week");
+        if (runs == null)
+            throw new RemessoError("invalid", "runs is required: how many payments");
+        if (!Number.isInteger(runs) || runs < 1 || runs > 4_294_967_295)
+            throw new RemessoError("invalid", "runs must be a whole number of payments");
+        if ((amount == null) === (receive == null))
+            throw new RemessoError("invalid", "give amount (what you send each time) or receive (what arrives), not both");
+        const [allowed, feeBps, maxLifetime, approved, balance] = await ctx.pub.multicall({
+            allowFailure: false,
+            contracts: [
+                { address: EXECUTOR, abi: executorAbi, functionName: "directTokenAllowed", args: [t.address] },
+                { address: EXECUTOR, abi: executorAbi, functionName: "feeBps" },
+                { address: EXECUTOR, abi: executorAbi, functionName: "MAX_LIFETIME" },
+                { address: t.address, abi: erc20Abi, functionName: "allowance", args: [account.address, EXECUTOR] },
+                { address: t.address, abi: erc20Abi, functionName: "balanceOf", args: [account.address] },
+            ],
+        });
+        if (!allowed)
+            throw new RemessoError("refused", `the contract doesn't take ${t.symbol} for new schedules`);
+        const amountIn = receive != null ? grossFor(toUnits(receive, t), Number(feeBps)) : toUnits(amount, t);
+        const { min, max } = runLimits(t);
+        if (amountIn < min || amountIn > max) {
+            throw new RemessoError("refused", `Remesso's executor sends ${formatAmount(min, t)} to ${formatAmount(max, t)} per payment, and this is ${formatAmount(amountIn, t)}. ` +
+                `A schedule outside that is valid on-chain and never runs.`);
+        }
+        const now = Math.floor(Date.now() / 1000);
+        const first = input.firstRunAt ? Math.floor(input.firstRunAt.getTime() / 1000) : now;
+        if (first < now - 60)
+            throw new RemessoError("invalid", "firstRunAt is in the past");
+        // An interval and an hour past the first payment's slot, as the example
+        // and the app do, so a run sent late still lands inside the schedule's
+        // life. `runs` still caps how many go out.
+        const expiresAt = first + runs * interval + 3600;
+        if (BigInt(expiresAt - now) > maxLifetime) {
+            throw new RemessoError("refused", `${runs} payments every ${interval / 86_400} days don't fit in a schedule's year`);
+        }
+        let trigger = zeroAddress;
+        if (input.trigger === "remesso")
+            trigger = CURRENT_EXECUTOR;
+        else if (input.trigger)
+            trigger = checksum(input.trigger);
+        const triggersLeft = trigger === zeroAddress ? 0 : Math.min(input.triggers ?? runs, 65_535);
+        const total = amountIn * BigInt(runs);
+        if (balance < amountIn)
+            warnings.push(`the balance (${formatAmount(balance, t)}) is below one payment: payments fail until it's funded`);
+        // The allowance is the real ceiling on what can ever be taken. Approve
+        // this schedule's total ON TOP of what is approved already: `approve`
+        // replaces rather than adds, and another schedule may rely on it.
+        let nonce = await ctx.pub.getTransactionCount({ address: account.address, blockTag: "pending" });
+        let approveHash = null;
+        if (input.approve !== false) {
+            ({ hash: approveHash } = await write(ctx, {
+                address: t.address, abi: erc20Abi, functionName: "approve", args: [EXECUTOR, approved + total], gasToken: t, nonce,
+            }));
+            nonce++;
+        }
+        const { hash, receipt } = await write(ctx, {
+            address: EXECUTOR,
+            abi: executorAbi,
+            functionName: "createSchedule",
+            args: [dest, amountIn, BigInt(interval), 0n, runs, BigInt(expiresAt), BigInt(input.firstRunAt ? first : 0), DIRECT, t.address, zeroAddress, trigger, triggersLeft],
+            gasToken: t,
+            nonce,
+        });
+        const id = scheduleIdFrom(receipt.logs);
+        if (id == null)
+            throw new RemessoError("http", `created, but ${hash} has no ScheduleCreated log: read the receipt yourself`, { hash });
+        let answered;
+        if (req) {
+            try {
+                answered = await deps.answer(req.id, id);
+            }
+            catch (e) {
+                answered = { error: e.message };
+            }
+        }
+        return {
+            id,
+            hash,
+            approveHash,
+            to: dest,
+            token: t.symbol,
+            amountIn,
+            recipientGets: netOf(amountIn, Number(feeBps)),
+            feeBps: Number(feeBps),
+            runs,
+            intervalSeconds: interval,
+            firstRunAt: new Date(first * 1000),
+            expiresAt: new Date(expiresAt * 1000),
+            ...(answered ? { request: answered } : {}),
+            warnings,
+        };
+    }
+    return {
+        create,
+        get,
+        /// Whether a payment is due now, and whether it can go: funded and approved.
+        async status(id) {
+            const [due, funded, approved, , nextRunAt] = await read("runnability", [BigInt(id)]);
+            return { due, funded, approved, nextRunAt: new Date(Number(nextRunAt) * 1000) };
+        },
+        /// The ids of every schedule `sender` (default: this account) has created.
+        async list(sender) {
+            const who = sender ? checksum(sender) : ctx.requireAccount().address;
+            return [...(await read("schedulesOf", [who]))];
+        },
+        /// Stops it for good. The approval stays: lower it if nothing else needs it.
+        async cancel(id) {
+            return (await write(ctx, {
+                address: EXECUTOR, abi: executorAbi, functionName: "cancelSchedule", args: [BigInt(id)], gasToken: await gasTokenOf(id),
+            })).hash;
+        },
+        /// Pauses (false) or resumes (true) the payments.
+        async setActive(id, active) {
+            return (await write(ctx, {
+                address: EXECUTOR, abi: executorAbi, functionName: "setScheduleActive", args: [BigInt(id), active], gasToken: await gasTokenOf(id),
+            })).hash;
+        },
+        /// Changes who may bring a payment forward; `null` revokes.
+        async setTrigger(id, trigger, triggers = 0) {
+            const who = trigger === "remesso" ? CURRENT_EXECUTOR : trigger ? checksum(trigger) : zeroAddress;
+            return (await write(ctx, {
+                address: EXECUTOR, abi: executorAbi, functionName: "setTrigger", args: [BigInt(id), who, who === zeroAddress ? 0 : triggers],
+                gasToken: await gasTokenOf(id),
+            })).hash;
+        },
+    };
+}
+/// The id of the schedule a transaction created, from its own ScheduleCreated
+/// log, never from re-reading the counter: a node a block behind would answer
+/// with somebody else's id. Null when there is none.
+export function scheduleIdFrom(logs) {
+    const created = parseEventLogs({ abi: executorAbi, eventName: "ScheduleCreated", logs: logs })
+        .find((l) => l.address.toLowerCase() === EXECUTOR.toLowerCase());
+    return created ? created.args.id : null;
+}
+/// Seconds for a cadence name or a number of seconds.
+export function intervalOf(every) {
+    if (typeof every === "number") {
+        if (!Number.isInteger(every) || every < 3600)
+            throw new RemessoError("invalid", "every, in seconds, must be a whole number of at least 3600");
+        return every;
+    }
+    const named = CADENCES[String(every).toLowerCase().replace(/ly$/, "")];
+    if (named)
+        return named;
+    if (/^\d+$/.test(String(every)))
+        return intervalOf(Number(every));
+    throw new RemessoError("invalid", `every must be ${Object.keys(CADENCES).join(", ")} or seconds`);
+}

package/dist/store.d.ts

@@ -0,0 +1,24 @@
+import type { Address, Hex } from "viem";
+export type PaymentRecord = {
+    key: string | null;
+    deployment: string;
+    policyId: string;
+    to: Address;
+    units: string;
+    token: Address;
+    memo: Hex;
+    hash: Hex;
+    nonce: number;
+    raw: Hex;
+    status: "sent" | "confirmed" | "reverted" | "unsent" | "dropped";
+    at: string;
+};
+export interface PaymentStore {
+    byKey(key: string, deployment: string): Promise<PaymentRecord | undefined>;
+    since(since: number): Promise<PaymentRecord[]>;
+    save(rec: PaymentRecord): Promise<void>;
+}
+export declare const KEEP_MS: number;
+export declare const KEEP_COUNT = 1000;
+export declare function upsert(list: PaymentRecord[], rec: PaymentRecord, now?: number): PaymentRecord[];
+export declare function memoryStore(): PaymentStore;

package/dist/store.js

@@ -0,0 +1,19 @@
+/// How long records are kept, and how many.
+export const KEEP_MS = 30 * 86_400_000;
+export const KEEP_COUNT = 1000;
+/// Applies `save`'s replacement rule and the retention to a list.
+export function upsert(list, rec, now = Date.now()) {
+    const cutoff = now - KEEP_MS;
+    const rest = list.filter((p) => p.hash !== rec.hash && !(rec.key && p.key === rec.key && p.deployment === rec.deployment) && Date.parse(p.at) > cutoff);
+    return [...rest, rec].slice(-KEEP_COUNT);
+}
+export function memoryStore() {
+    let list = [];
+    return {
+        byKey: async (key, deployment) => [...list].reverse().find((p) => p.key === key && p.deployment === deployment),
+        since: async (since) => list.filter((p) => Date.parse(p.at) > since),
+        save: async (rec) => {
+            list = upsert(list, rec);
+        },
+    };
+}

package/dist/vendor/erc8021.d.ts

@@ -0,0 +1,9 @@
+export declare const MARKER = "80218021802180218021802180218021";
+export declare const CODE: RegExp;
+export declare const OWN_CODES: readonly string[];
+export declare const MAX_INTEGRATOR_CODES = 3;
+export declare function suffixFor(codes: string | readonly string[]): `0x${string}` | undefined;
+export declare function parseSuffix(input: string): {
+    codes: string[];
+} | null;
+export declare function integratorCodes(codes: readonly string[], own?: readonly string[]): string[];

package/dist/vendor/erc8021.js

@@ -0,0 +1,82 @@
+// Copied from supabase/functions/_shared/erc8021.ts by scripts/build-sdk.ts. Edit the original and re-run;
+// `build-sdk.ts --check` fails while the two differ.
+/// ERC-8021 Schema 0: writing a suffix, reading one back, and which of the
+/// codes an integrator's transaction carries ride on the runs that follow it.
+///
+/// Pure, with no environment, so `remesso-sdk` carries an exact copy
+/// (`scripts/build-sdk.ts`): a builder code the SDK accepts is one the backend
+/// keeps. `attribution.ts` adds Remesso's own configured codes on top.
+/// `attribution.test.ts` pins both directions to `@celo/attribution-tags`.
+/// `[code:N][length:1][schema:1][marker:16]`
+export const MARKER = "80218021802180218021802180218021";
+const SCHEMA_0 = "00";
+/// What Celo's SDK accepts in `toDataSuffix`.
+export const CODE = /^[a-z0-9_]{1,32}$/;
+/// Remesso's own codes, whether or not they're carried today. `remesso-sdk`
+/// 0.1.0 writes both on every transaction, so a schedule created with it
+/// after the event code leaves `ATTRIBUTION_CODE` must not hand that code
+/// back to our runs as if it were an integrator's.
+export const OWN_CODES = ["remesso", "celo_5cd35ca55baf"];
+/// How many of an integrator's codes ride on each run. Each costs calldata
+/// gas on every run, and three cover an app, a wallet and one partner.
+export const MAX_INTEGRATOR_CODES = 3;
+/// The suffix for one code or several, or `undefined` if none is usable.
+///
+/// Never throws: a malformed tag must not be the reason a remittance fails to
+/// go out. A bad code is dropped and the rest still tag — a typo in one must
+/// not cost the other its credit, since an untagged transaction stays
+/// untagged forever. A comma inside a single code is refused rather than read
+/// as a list; a list is passed as an array.
+export function suffixFor(codes) {
+    const list = (typeof codes === "string" ? [codes] : codes).filter((code) => {
+        if (CODE.test(code))
+            return true;
+        console.error("attribution code must be 1-32 of [a-z0-9_]:", code);
+        return false;
+    });
+    if (list.length === 0)
+        return undefined;
+    const field = list.join(",");
+    // The length is one byte.
+    if (field.length > 255)
+        return undefined;
+    const hex = [...new TextEncoder().encode(field)]
+        .map((b) => b.toString(16).padStart(2, "0"))
+        .join("");
+    const length = field.length.toString(16).padStart(2, "0");
+    return `0x${hex}${length}${SCHEMA_0}${MARKER}`;
+}
+/// The codes in a transaction's Schema 0 suffix, read from the end the way
+/// Celo's `fromDataSuffix` reads them: the marker, the schema byte, the length
+/// byte, then that many bytes of comma-joined codes, returned as written.
+///
+/// Null when there is no suffix, when it is another schema (Schema 2's roles
+/// aren't read), or when the length runs past the start of the input. ox
+/// reads whatever bytes are there in that last case; nothing honest writes it.
+export function parseSuffix(input) {
+    const hex = input.toLowerCase().replace(/^0x/, "");
+    if (hex.length % 2 !== 0 || hex.length < 36 || !/^[0-9a-f]*$/.test(hex))
+        return null;
+    if (hex.slice(-32) !== MARKER || hex.slice(-34, -32) !== SCHEMA_0)
+        return null;
+    const length = parseInt(hex.slice(-36, -34), 16);
+    if (length === 0 || hex.length < 36 + length * 2)
+        return null;
+    const field = hex.slice(-36 - length * 2, -36);
+    const bytes = Uint8Array.from(field.match(/../g), (b) => parseInt(b, 16));
+    return { codes: new TextDecoder().decode(bytes).split(",") };
+}
+/// Which of a creating transaction's codes ride on a schedule's runs: Celo's
+/// charset, none of Remesso's own (they're carried anyway), no repeats, and
+/// the first three in the order written.
+export function integratorCodes(codes, own = OWN_CODES) {
+    const out = [];
+    for (const code of codes) {
+        if (!CODE.test(code) || own.includes(code) || out.includes(code))
+            continue;
+        out.push(code);
+        if (out.length === MAX_INTEGRATOR_CODES)
+            break;
+    }
+    return out;
+}

package/dist/vendor/fee.d.ts

@@ -0,0 +1,3 @@
+export declare function feeOf(gross: bigint, bps: number): bigint;
+export declare function netOf(gross: bigint, bps: number): bigint;
+export declare function grossFor(net: bigint, bps: number): bigint;