@defdone/annon 0.0.0-stage → 0.1.0-alpha.1

package/dist/wallet/wallet.d.ts

@@ -0,0 +1,100 @@
+import type { Account } from 'near-api-js';
+import { AnnonError } from '../errors.js';
+import { type NearMessage, type NearSignedMessage, type RecoveryProofContext } from '../near/nep413.js';
+import type { TypedData } from '../pay/eip3009.js';
+import { type Authorization, type Identity } from '../settle-near/identity.js';
+import type { SettlementAssets } from '../settle-near/terms.js';
+export interface IdentityWallet {
+    identity: Identity;
+    authorize(text: string): Promise<Authorization | undefined>;
+}
+export interface EvmWallet extends IdentityWallet {
+    address: string;
+    signTypedData(data: TypedData): Promise<string>;
+}
+/** Accept an EIP-1193 provider or the provider member of an EIP-6963 announcement. */
+export declare function evmWallet(input: {
+    request(args: {
+        method: string;
+        params?: unknown;
+    }): Promise<unknown>;
+} | {
+    provider: {
+        request(args: {
+            method: string;
+            params?: unknown;
+        }): Promise<unknown>;
+    };
+}, address: string): EvmWallet;
+export interface SolanaAccount {
+    publicKey: Uint8Array;
+    address: string;
+}
+export interface SolanaStandard {
+    features: {
+        'solana:signMessage': {
+            signMessage(...inputs: {
+                account: SolanaAccount;
+                message: Uint8Array;
+            }[]): Promise<readonly {
+                signature: Uint8Array;
+                signedMessage: Uint8Array;
+            }[]>;
+        };
+    };
+}
+export declare function solanaWallet(wallet: SolanaStandard, account: SolanaAccount): IdentityWallet;
+export interface NearCall {
+    receiverId: string;
+    method: string;
+    args: object;
+    gas?: bigint;
+    deposit?: bigint;
+}
+export interface NearWallet extends IdentityWallet {
+    call(call: NearCall): Promise<unknown>;
+    transferPurchase(message: string, assets?: SettlementAssets): Promise<unknown>;
+    /** Adapters default to NEP-413 plus a final full-access-key check before using NEAR recovery. */
+    proveControl?: (text: string, context: RecoveryProofContext) => Promise<void>;
+}
+export interface SelectorWallet {
+    signMessage?: (p: NearMessage) => Promise<NearSignedMessage | undefined>;
+    getAccounts(): Promise<readonly {
+        accountId: string;
+    }[]>;
+    signAndSendTransaction(tx: {
+        signerId: string;
+        receiverId: string;
+        actions: {
+            type: 'FunctionCall';
+            params: {
+                methodName: string;
+                args: object;
+                gas: string;
+                deposit: string;
+            };
+        }[];
+    }): Promise<unknown>;
+}
+export declare function nearSelectorWallet(wallet: SelectorWallet, accountId: string, proveControl?: NearWallet['proveControl']): NearWallet;
+/** Pass a near-api-js Account constructed with a KeyPair signer. The account sends the call itself. */
+export declare function nearKeyPairWallet(account: {
+    accountId: string;
+    getSigner?: Account['getSigner'];
+    callFunction(args: {
+        contractId: string;
+        methodName: string;
+        args: object;
+        gas: bigint;
+        deposit: bigint;
+    }): Promise<unknown>;
+}, proveControl?: NearWallet['proveControl']): NearWallet;
+/** Prepay Annon storage explicitly before zero-deposit register/reopen calls. */
+export declare function storageDeposit(wallet: Pick<NearWallet, 'call'>, contract: string, amount: bigint): Promise<unknown>;
+/** A final funding refusal, safe to correct and retry. */
+export declare class FileFundingRefused extends AnnonError {
+    readonly code = "funding_refused";
+    constructor();
+}
+/** Explicit, nonwithdrawable purchase storage allocation. Zero attachment uses own prepaid balance. */
+export declare function fundFileStorage(wallet: Pick<NearWallet, 'call'>, contract: string, fileId: string, amount: bigint, prepaid?: boolean): Promise<unknown>;

package/dist/wallet/wallet.js

@@ -0,0 +1,204 @@
+/** Wallet adapters: authoritative text in, checked authorization out. No browser globals. */
+import { base64 } from '@scure/base';
+import { signMessage as signNearMessage } from 'near-api-js/nep413';
+import { createWalletClient, custom } from 'viem';
+import { base } from 'viem/chains';
+import { AnnonError } from '../errors.js';
+import { proveNearControl, } from '../near/nep413.js';
+import { readOutcome } from '../near/rpc.js';
+import { hex, account as nearAccount } from '../settle-near/codec.js';
+import { parseIdentity, solanaWalletAuth, verifyAuthorization, } from '../settle-near/identity.js';
+import { parsePurchaseMessage } from '../settle-near/purchase.js';
+/** Accept an EIP-1193 provider or the provider member of an EIP-6963 announcement. */
+export function evmWallet(input, address) {
+    const provider = 'provider' in input ? input.provider : input;
+    const identity = parseIdentity({ kind: 'evm', id: address });
+    const client = createWalletClient({
+        chain: base,
+        transport: custom(provider),
+    });
+    const selected = async () => {
+        const accounts = await provider.request({ method: 'eth_accounts' });
+        if (!Array.isArray(accounts) ||
+            !accounts.some((a) => typeof a === 'string' && a.toLowerCase() === identity.id))
+            throw new AnnonError('wrong_identity', 'wallet does not control the selected identity');
+    };
+    return {
+        identity,
+        address: identity.id,
+        async authorize(text) {
+            await selected();
+            const sig = await client.signMessage({
+                account: identity.id,
+                message: text,
+            });
+            const auth = { kind: 'evm', sig };
+            if (!verifyAuthorization(identity, text, auth))
+                throw new AnnonError('invalid_signature', 'wallet signature does not match identity');
+            return auth;
+        },
+        async signTypedData(data) {
+            await selected();
+            return client.signTypedData({
+                ...data,
+                account: identity.id,
+            });
+        },
+    };
+}
+export function solanaWallet(wallet, account) {
+    const identity = parseIdentity({ kind: 'solana', id: hex(account.publicKey).slice(2) });
+    return {
+        identity,
+        async authorize(text) {
+            const results = await wallet.features['solana:signMessage'].signMessage({
+                account,
+                message: new TextEncoder().encode(text),
+            });
+            if (results.length !== 1 || !results[0])
+                throw new AnnonError('invalid_signature', 'wallet returned no single signature');
+            return solanaWalletAuth(identity, text, results[0]);
+        },
+    };
+}
+function nearWallet(accountId, selected, call, proveControl) {
+    const identity = parseIdentity({ kind: 'near', id: accountId });
+    return {
+        identity,
+        ...(proveControl ? { proveControl } : {}),
+        async authorize(_text) {
+            await selected();
+            return undefined;
+        },
+        async call(request) {
+            await selected();
+            return call(request);
+        },
+        async transferPurchase(message, assets) {
+            const p = parsePurchaseMessage(message, assets);
+            if (p.route !== 'near-usdc')
+                throw new TypeError('not a NEAR USDC purchase');
+            if (BigInt(p.expires_at) <= BigInt(Math.floor(Date.now() / 1000)))
+                throw new AnnonError('payment_expired', 'purchase expired');
+            await selected();
+            return call({
+                receiverId: p.asset,
+                method: 'ft_transfer_call',
+                args: { receiver_id: p.contract, amount: p.price, msg: message },
+                gas: 150000000000000n,
+                deposit: 1n,
+            });
+        },
+    };
+}
+export function nearSelectorWallet(wallet, accountId, proveControl) {
+    return nearWallet(accountId, async () => {
+        if (!(await wallet.getAccounts()).some((a) => a.accountId === accountId))
+            throw new AnnonError('wrong_identity', 'wallet does not control the NEAR account');
+    }, (call) => wallet.signAndSendTransaction({
+        signerId: accountId,
+        receiverId: call.receiverId,
+        actions: [
+            {
+                type: 'FunctionCall',
+                params: {
+                    methodName: call.method,
+                    args: call.args,
+                    gas: String(call.gas ?? 300000000000000n),
+                    deposit: String(call.deposit ?? 0n),
+                },
+            },
+        ],
+    }), proveControl ??
+        ((text, context) => {
+            if (!wallet.signMessage)
+                throw new AnnonError('missing_method', 'NEAR recovery requires NEP-413 signMessage');
+            return proveNearControl(accountId, text, context, (p) => wallet.signMessage?.(p) ?? Promise.resolve(undefined));
+        }));
+}
+/** Pass a near-api-js Account constructed with a KeyPair signer. The account sends the call itself. */
+export function nearKeyPairWallet(account, proveControl) {
+    return nearWallet(account.accountId, async () => { }, (call) => account.callFunction({
+        contractId: call.receiverId,
+        methodName: call.method,
+        args: call.args,
+        gas: call.gas ?? 300000000000000n,
+        deposit: call.deposit ?? 0n,
+    }), proveControl ??
+        (async (text, context) => {
+            if (!account.getSigner)
+                throw new AnnonError('missing_method', 'NEAR recovery requires a NEP-413 signer');
+            await proveNearControl(account.accountId, text, context, async (payload) => {
+                const result = await signNearMessage({ signerAccount: account, payload });
+                return {
+                    accountId: result.accountId,
+                    publicKey: result.publicKey.toString(),
+                    signature: base64.encode(result.signature),
+                };
+            });
+        }));
+}
+/** Prepay Annon storage explicitly before zero-deposit register/reopen calls. */
+export async function storageDeposit(wallet, contract, amount) {
+    if (amount <= 0n)
+        throw new RangeError('storage deposit must be positive');
+    return wallet.call({
+        receiverId: nearAccount(contract),
+        method: 'storage_deposit',
+        args: {},
+        deposit: amount,
+        gas: 30000000000000n,
+    });
+}
+/** A final funding refusal, safe to correct and retry. */
+export class FileFundingRefused extends AnnonError {
+    code = 'funding_refused';
+    constructor() {
+        super('funding_refused', 'File funding was refused.');
+        this.name = 'FileFundingRefused';
+    }
+}
+/** Explicit, nonwithdrawable purchase storage allocation. Zero attachment uses own prepaid balance. */
+export async function fundFileStorage(wallet, contract, fileId, amount, prepaid = false) {
+    if (amount <= 0n || amount >= 2n ** 128n || !/^0x[0-9a-f]{64}$/.test(fileId))
+        throw new RangeError('invalid file funding');
+    const request = {
+        receiverId: nearAccount(contract),
+        method: 'fund_file_storage',
+        args: { file_id: fileId, amount: amount.toString() },
+        deposit: prepaid ? 0n : amount,
+        gas: 30000000000000n,
+    };
+    const refused = (result) => {
+        if (!result || typeof result !== 'object' || !('transaction' in result))
+            return false;
+        try {
+            const transaction = result
+                .transaction;
+            return (readOutcome(result, contract, {
+                txHash: transaction.hash,
+                signer: transaction.signer_id,
+                method: request.method,
+                args: request.args,
+            }).state === 'refused');
+        }
+        catch {
+            return false;
+        }
+    };
+    let result;
+    try {
+        result = await wallet.call(request);
+    }
+    catch (error) {
+        if (error &&
+            typeof error === 'object' &&
+            'transactionResult' in error &&
+            refused(error.transactionResult))
+            throw new FileFundingRefused();
+        throw error;
+    }
+    if (refused(result))
+        throw new FileFundingRefused();
+    return result;
+}

package/package.json

@@ -1,6 +1,139 @@
 {
   "name": "@defdone/annon",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
+  "version": "0.1.0-alpha.1",
+  "description": "Files only the buyer can open: encrypted on the client, the key released by NEAR once the payment is verified.",
+  "license": "Apache-2.0",
+  "homepage": "https://annon.dev",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/defdone/annon.git",
+    "directory": "packages/annon"
+  },
+  "bugs": {
+    "url": "https://github.com/defdone/annon/issues"
+  },
+  "keywords": [
+    "near",
+    "x402",
+    "encryption",
+    "payments",
+    "usdc",
+    "mpc",
+    "files",
+    "agents",
+    "cli"
+  ],
+  "engines": {
+    "node": ">=22"
+  },
+  "publishConfig": {
+    "access": "public",
+    "tag": "alpha"
+  },
+  "type": "module",
+  "bin": {
+    "annon": "./dist/node/main.js"
+  },
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "default": "./dist/index.js"
+    },
+    "./browser": {
+      "types": "./dist/browser/index.d.ts",
+      "default": "./dist/browser/index.js"
+    },
+    "./browser/purchase-bundle.js": "./dist/browser/purchase-bundle.js",
+    "./node": {
+      "types": "./dist/node/index.d.ts",
+      "default": "./dist/node/index.js"
+    },
+    "./relay": {
+      "types": "./dist/relay/index.d.ts",
+      "default": "./dist/relay/index.js"
+    },
+    "./download/host": {
+      "types": "./dist/download/host.d.ts",
+      "default": "./dist/download/host.js"
+    },
+    "./download/http": {
+      "types": "./dist/download/http.d.ts",
+      "default": "./dist/download/http.js"
+    },
+    "./envelope/pay2": {
+      "types": "./dist/envelope/pay2.d.ts",
+      "default": "./dist/envelope/pay2.js"
+    },
+    "./near/rpc": {
+      "types": "./dist/near/rpc.d.ts",
+      "default": "./dist/near/rpc.js"
+    },
+    "./pay/seller": {
+      "types": "./dist/pay/seller.d.ts",
+      "default": "./dist/pay/seller.js"
+    },
+    "./pay/settle": {
+      "types": "./dist/pay/settle.d.ts",
+      "default": "./dist/pay/settle.js"
+    },
+    "./pay/split": {
+      "types": "./dist/pay/split.d.ts",
+      "default": "./dist/pay/split.js"
+    },
+    "./pay/store": {
+      "types": "./dist/pay/store.d.ts",
+      "default": "./dist/pay/store.js"
+    },
+    "./pay/store-node": {
+      "types": "./dist/pay/store-node.d.ts",
+      "default": "./dist/pay/store-node.js"
+    },
+    "./node/signer-mock": {
+      "types": "./dist/node/signer-mock.d.ts",
+      "default": "./dist/node/signer-mock.js"
+    },
+    "./node/adapter": {
+      "types": "./dist/node/adapter.d.ts",
+      "default": "./dist/node/adapter.js"
+    },
+    "./node/cli": {
+      "types": "./dist/node/cli.d.ts",
+      "default": "./dist/node/cli.js"
+    },
+    "./node/errors": {
+      "types": "./dist/node/errors.d.ts",
+      "default": "./dist/node/errors.js"
+    }
+  },
+  "files": [
+    "dist",
+    "CLI.md",
+    "README.md",
+    "LICENSE",
+    "NOTICE",
+    "CHANGELOG.md"
+  ],
+  "devDependencies": {
+    "@near-wallet-selector/core": "10.1.4",
+    "@near-wallet-selector/hot-wallet": "10.1.4",
+    "@near-wallet-selector/meteor-wallet": "10.1.4",
+    "@types/node": "26.6.5",
+    "buffer": "6.0.3",
+    "esbuild": "0.28.2",
+    "fake-indexeddb": "6.2.6",
+    "util": "0.12.5",
+    "vitest": "5.0.5"
+  },
+  "dependencies": {
+    "@noble/curves": "2.4.0",
+    "@noble/hashes": "2.4.0",
+    "@scure/base": "2.4.0",
+    "near-api-js": "7.4.0",
+    "viem": "2.57.10"
+  },
+  "scripts": {
+    "build": "rm -rf dist && tsc --noEmit && tsc -p tsconfig.build.json && node scripts/build-browser.ts",
+    "test": "vitest run && pnpm validate:package",
+    "validate:package": "node scripts/check-package.mjs"
+  }
 }