@4mica/sdk 1.2.17 → 1.3.1

package/dist/src/signing.js

@@ -1,311 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.PaymentSigner = exports.GUARANTEE_EIP712_TYPES_V2 = exports.GUARANTEE_EIP712_TYPES = exports.computeValidationRequestHash = exports.computeValidationSubjectHash = void 0;
-exports.validateGuaranteeTypedData = validateGuaranteeTypedData;
-exports.validateGuaranteeSigningContext = validateGuaranteeSigningContext;
-exports.buildGuaranteeTypedData = buildGuaranteeTypedData;
-exports.buildGuaranteeTypedDataV2 = buildGuaranteeTypedDataV2;
-exports.encodeGuaranteeEip191V2 = encodeGuaranteeEip191V2;
-exports.encodeGuaranteeEip191 = encodeGuaranteeEip191;
-const viem_1 = require("viem");
-var validation_1 = require("./validation");
-Object.defineProperty(exports, "computeValidationSubjectHash", { enumerable: true, get: function () { return validation_1.computeValidationSubjectHash; } });
-Object.defineProperty(exports, "computeValidationRequestHash", { enumerable: true, get: function () { return validation_1.computeValidationRequestHash; } });
-const errors_1 = require("./errors");
-const models_1 = require("./models");
-const utils_1 = require("./utils");
-const serde_1 = require("./serde");
-exports.GUARANTEE_EIP712_TYPES = {
-    EIP712Domain: [
-        { name: 'name', type: 'string' },
-        { name: 'version', type: 'string' },
-        { name: 'chainId', type: 'uint256' },
-    ],
-    SolGuaranteeRequestClaimsV1: [
-        { name: 'user', type: 'address' },
-        { name: 'recipient', type: 'address' },
-        { name: 'tabId', type: 'uint256' },
-        { name: 'reqId', type: 'uint256' },
-        { name: 'amount', type: 'uint256' },
-        { name: 'asset', type: 'address' },
-        { name: 'timestamp', type: 'uint64' },
-    ],
-};
-exports.GUARANTEE_EIP712_TYPES_V2 = {
-    EIP712Domain: [
-        { name: 'name', type: 'string' },
-        { name: 'version', type: 'string' },
-        { name: 'chainId', type: 'uint256' },
-    ],
-    SolGuaranteeRequestClaimsV2: [
-        { name: 'user', type: 'address' },
-        { name: 'recipient', type: 'address' },
-        { name: 'tabId', type: 'uint256' },
-        { name: 'reqId', type: 'uint256' },
-        { name: 'amount', type: 'uint256' },
-        { name: 'asset', type: 'address' },
-        { name: 'timestamp', type: 'uint64' },
-        { name: 'validationRegistryAddress', type: 'address' },
-        { name: 'validationRequestHash', type: 'bytes32' },
-        { name: 'validationChainId', type: 'uint256' },
-        { name: 'validatorAddress', type: 'address' },
-        { name: 'validatorAgentId', type: 'uint256' },
-        { name: 'minValidationScore', type: 'uint8' },
-        { name: 'validationSubjectHash', type: 'bytes32' },
-        { name: 'jobHash', type: 'bytes32' },
-        { name: 'requiredValidationTag', type: 'string' },
-    ],
-};
-const fieldsMatch = (actual, expected) => {
-    if (!Array.isArray(actual) || actual.length !== expected.length)
-        return false;
-    const norm = (list) => list.map((item) => `${item.name}:${item.type}`).sort();
-    const actualSet = new Set(norm(actual));
-    return norm(expected).every((key) => actualSet.has(key));
-};
-const parseChainId = (value) => {
-    if (typeof value === 'bigint')
-        return Number(value);
-    if (typeof value === 'number')
-        return value;
-    if (typeof value === 'string' && value.trim())
-        return Number(value);
-    return Number.NaN;
-};
-const ensureBigIntish = (value, label) => {
-    try {
-        BigInt(value);
-    }
-    catch {
-        throw new utils_1.ValidationError(`${label} must be a numeric value`);
-    }
-};
-function validateGuaranteeTypedData(payload, options = {}) {
-    if (!(0, serde_1.isRecord)(payload)) {
-        throw new utils_1.ValidationError('typed data payload is required');
-    }
-    if (!(0, serde_1.isRecord)(payload.domain)) {
-        throw new utils_1.ValidationError('domain is required');
-    }
-    if (!(0, serde_1.isRecord)(payload.types)) {
-        throw new utils_1.ValidationError('types are required');
-    }
-    if (!(0, serde_1.isRecord)(payload.message)) {
-        throw new utils_1.ValidationError('message is required');
-    }
-    const types = payload.types;
-    if (!fieldsMatch(types.SolGuaranteeRequestClaimsV1, exports.GUARANTEE_EIP712_TYPES.SolGuaranteeRequestClaimsV1)) {
-        throw new utils_1.ValidationError('Unexpected struct fields for SolGuaranteeRequestClaimsV1');
-    }
-    const message = payload.message;
-    const requiredFields = ['user', 'recipient', 'tabId', 'reqId', 'amount', 'asset', 'timestamp'];
-    if (requiredFields.some((field) => !(field in message))) {
-        throw new utils_1.ValidationError('message is missing required SolGuaranteeRequestClaimsV1 fields');
-    }
-    const user = (0, utils_1.normalizeAddress)(message.user);
-    const recipient = (0, utils_1.normalizeAddress)(message.recipient);
-    (0, utils_1.normalizeAddress)(message.asset);
-    if (options.expectedSigner) {
-        if ((0, utils_1.normalizeAddress)(options.expectedSigner) !== user) {
-            throw new utils_1.ValidationError('message.user must match signer address');
-        }
-    }
-    if (options.expectedRecipient) {
-        if ((0, utils_1.normalizeAddress)(options.expectedRecipient) !== recipient) {
-            throw new utils_1.ValidationError('message.recipient must match expected recipient');
-        }
-    }
-    ensureBigIntish(message.tabId, 'tabId');
-    ensureBigIntish(message.reqId, 'reqId');
-    ensureBigIntish(message.amount, 'amount');
-    ensureBigIntish(message.timestamp, 'timestamp');
-    if (options.expectedChainId !== undefined) {
-        const domainChainId = parseChainId(payload.domain.chainId);
-        if (!Number.isFinite(domainChainId)) {
-            throw new utils_1.ValidationError('domain.chainId is required for typed data signatures');
-        }
-        if (Number(domainChainId) !== Number(options.expectedChainId)) {
-            throw new utils_1.ValidationError(`domain.chainId mismatch; expected ${options.expectedChainId}, got ${domainChainId}`);
-        }
-    }
-}
-function validateGuaranteeSigningContext(params, claims, options = {}) {
-    if (options.signerAddress) {
-        const signer = (0, utils_1.normalizeAddress)(options.signerAddress);
-        const user = (0, utils_1.normalizeAddress)(claims.userAddress);
-        if (signer !== user) {
-            throw new utils_1.ValidationError(`address mismatch: signer ${options.signerAddress} != claims.user_address ${claims.userAddress}`);
-        }
-    }
-    if (options.signerChainId !== undefined) {
-        const signerChainId = Number(options.signerChainId);
-        if (!Number.isFinite(signerChainId)) {
-            throw new utils_1.ValidationError('signer chain id is invalid');
-        }
-        if (Number(params.chainId) !== signerChainId) {
-            throw new utils_1.ValidationError(`chain id mismatch: expected ${params.chainId}, got ${signerChainId}`);
-        }
-    }
-}
-function buildGuaranteeTypedData(params, claims) {
-    return {
-        types: exports.GUARANTEE_EIP712_TYPES,
-        primaryType: 'SolGuaranteeRequestClaimsV1',
-        domain: {
-            name: params.eip712Name,
-            version: params.eip712Version,
-            chainId: params.chainId,
-        },
-        message: {
-            user: claims.userAddress,
-            recipient: claims.recipientAddress,
-            tabId: claims.tabId,
-            reqId: claims.reqId,
-            amount: claims.amount,
-            asset: claims.assetAddress,
-            timestamp: BigInt(claims.timestamp),
-        },
-    };
-}
-function buildGuaranteeTypedDataV2(params, claims) {
-    return {
-        types: exports.GUARANTEE_EIP712_TYPES_V2,
-        primaryType: 'SolGuaranteeRequestClaimsV2',
-        domain: {
-            name: params.eip712Name,
-            version: params.eip712Version,
-            chainId: params.chainId,
-        },
-        message: {
-            user: claims.userAddress,
-            recipient: claims.recipientAddress,
-            tabId: claims.tabId,
-            reqId: claims.reqId,
-            amount: claims.amount,
-            asset: claims.assetAddress,
-            timestamp: BigInt(claims.timestamp),
-            validationRegistryAddress: claims.validationRegistryAddress,
-            validationRequestHash: (0, utils_1.ensureHexPrefix)(claims.validationRequestHash),
-            validationChainId: BigInt(claims.validationChainId),
-            validatorAddress: claims.validatorAddress,
-            validatorAgentId: claims.validatorAgentId,
-            minValidationScore: claims.minValidationScore,
-            validationSubjectHash: (0, utils_1.ensureHexPrefix)(claims.validationSubjectHash),
-            jobHash: (0, utils_1.ensureHexPrefix)(claims.jobHash),
-            requiredValidationTag: claims.requiredValidationTag,
-        },
-    };
-}
-function encodeGuaranteeEip191V2(claims) {
-    return (0, viem_1.encodeAbiParameters)([
-        { type: 'address' },
-        { type: 'address' },
-        { type: 'uint256' },
-        { type: 'uint256' },
-        { type: 'uint256' },
-        { type: 'address' },
-        { type: 'uint64' },
-        { type: 'address' },
-        { type: 'bytes32' },
-        { type: 'uint256' },
-        { type: 'address' },
-        { type: 'uint256' },
-        { type: 'uint8' },
-        { type: 'bytes32' },
-        { type: 'bytes32' },
-        { type: 'string' },
-    ], [
-        claims.userAddress,
-        claims.recipientAddress,
-        claims.tabId,
-        claims.reqId,
-        claims.amount,
-        claims.assetAddress,
-        BigInt(claims.timestamp),
-        claims.validationRegistryAddress,
-        (claims.validationRequestHash.startsWith('0x')
-            ? claims.validationRequestHash
-            : `0x${claims.validationRequestHash}`),
-        BigInt(claims.validationChainId),
-        claims.validatorAddress,
-        claims.validatorAgentId,
-        claims.minValidationScore,
-        (claims.validationSubjectHash.startsWith('0x')
-            ? claims.validationSubjectHash
-            : `0x${claims.validationSubjectHash}`),
-        (claims.jobHash.startsWith('0x') ? claims.jobHash : `0x${claims.jobHash}`),
-        claims.requiredValidationTag,
-    ]);
-}
-function encodeGuaranteeEip191(claims) {
-    const payload = (0, viem_1.encodeAbiParameters)([
-        { type: 'address' },
-        { type: 'address' },
-        { type: 'uint256' },
-        { type: 'uint256' },
-        { type: 'uint256' },
-        { type: 'address' },
-        { type: 'uint64' },
-    ], [
-        claims.userAddress,
-        claims.recipientAddress,
-        claims.tabId,
-        claims.reqId,
-        claims.amount,
-        claims.assetAddress,
-        BigInt(claims.timestamp),
-    ]);
-    return payload;
-}
-class PaymentSigner {
-    signer;
-    constructor(signer) {
-        this.signer = signer;
-    }
-    async signRequest(params, claims, scheme = models_1.SigningScheme.EIP712) {
-        try {
-            validateGuaranteeSigningContext(params, claims, { signerAddress: this.signer.address });
-            const isV2 = claims instanceof models_1.PaymentGuaranteeRequestClaimsV2;
-            if (scheme === models_1.SigningScheme.EIP712) {
-                if (!this.signer.signTypedData) {
-                    throw new errors_1.SigningError('signTypedData is not supported for this account');
-                }
-                if (isV2) {
-                    const typed = buildGuaranteeTypedDataV2(params, claims);
-                    const signature = await this.signer.signTypedData({
-                        domain: typed.domain,
-                        types: { SolGuaranteeRequestClaimsV2: typed.types.SolGuaranteeRequestClaimsV2 },
-                        primaryType: typed.primaryType,
-                        message: typed.message,
-                    });
-                    return { signature, scheme };
-                }
-                const typed = buildGuaranteeTypedData(params, claims);
-                const signature = await this.signer.signTypedData({
-                    domain: typed.domain,
-                    types: { SolGuaranteeRequestClaimsV1: typed.types.SolGuaranteeRequestClaimsV1 },
-                    primaryType: typed.primaryType,
-                    message: typed.message,
-                });
-                return { signature, scheme };
-            }
-            if (scheme === models_1.SigningScheme.EIP191) {
-                if (!this.signer.signMessage) {
-                    throw new errors_1.SigningError('signMessage is not supported for this account');
-                }
-                const message = isV2 ? encodeGuaranteeEip191V2(claims) : encodeGuaranteeEip191(claims);
-                const signature = await this.signer.signMessage({ message });
-                return { signature, scheme };
-            }
-            throw new errors_1.SigningError(`unsupported signing scheme: ${scheme}`);
-        }
-        catch (err) {
-            if (err instanceof utils_1.ValidationError) {
-                throw new errors_1.SigningError(err.message);
-            }
-            const message = err instanceof Error ? err.message : String(err);
-            throw new errors_1.SigningError(message);
-        }
-    }
-}
-exports.PaymentSigner = PaymentSigner;

package/dist/src/utils.d.ts

@@ -1,11 +0,0 @@
-import { Hex } from 'viem';
-export declare class ValidationError extends Error {
-    constructor(message: string);
-}
-export declare function validateUrl(raw: string): string;
-export declare function normalizePrivateKey(raw: string): string;
-export declare function normalizeAddress(raw: string): string;
-export declare function ensureHexPrefix(value: string): Hex;
-export declare function parseU256(value: number | bigint | string): bigint;
-export declare function serializeU256(value: number | bigint | string): string;
-export declare function hexFromBytes(bytes: Uint8Array): Hex;

package/dist/src/utils.js

@@ -1,90 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.ValidationError = void 0;
-exports.validateUrl = validateUrl;
-exports.normalizePrivateKey = normalizePrivateKey;
-exports.normalizeAddress = normalizeAddress;
-exports.ensureHexPrefix = ensureHexPrefix;
-exports.parseU256 = parseU256;
-exports.serializeU256 = serializeU256;
-exports.hexFromBytes = hexFromBytes;
-const viem_1 = require("viem");
-class ValidationError extends Error {
-    constructor(message) {
-        super(message);
-        this.name = 'ValidationError';
-    }
-}
-exports.ValidationError = ValidationError;
-function validateUrl(raw) {
-    let url;
-    try {
-        url = new URL(raw);
-    }
-    catch {
-        throw new ValidationError(`invalid URL: ${raw}`);
-    }
-    if (!url.protocol || !url.host) {
-        throw new ValidationError(`invalid URL: ${raw}`);
-    }
-    return raw;
-}
-function normalizePrivateKey(raw) {
-    const key = raw.startsWith('0x') ? raw.slice(2) : raw;
-    if (!/^[0-9a-fA-F]{64}$/.test(key)) {
-        throw new ValidationError('invalid private key (expected 32 byte hex)');
-    }
-    return `0x${key.toLowerCase()}`;
-}
-function normalizeAddress(raw) {
-    const candidate = String(raw);
-    if ((0, viem_1.isAddress)(candidate)) {
-        return (0, viem_1.getAddress)(candidate);
-    }
-    const lower = candidate.toLowerCase();
-    if ((0, viem_1.isAddress)(lower)) {
-        return (0, viem_1.getAddress)(lower);
-    }
-    throw new ValidationError(`invalid address: ${raw}`);
-}
-function ensureHexPrefix(value) {
-    return (value.startsWith('0x') ? value : `0x${value}`);
-}
-function parseNumericString(raw) {
-    const text = raw.trim();
-    const n = BigInt(text);
-    if (n < 0n) {
-        throw new ValidationError('u256 cannot be negative');
-    }
-    return n;
-}
-function parseU256(value) {
-    if (typeof value === 'number') {
-        if (!Number.isFinite(value)) {
-            throw new ValidationError('invalid integer');
-        }
-        if (!Number.isSafeInteger(value)) {
-            throw new ValidationError('integer value exceeds safe precision; use bigint or hex string for large values');
-        }
-        if (value < 0) {
-            throw new ValidationError('u256 cannot be negative');
-        }
-        return BigInt(value);
-    }
-    if (typeof value === 'bigint') {
-        if (value < 0) {
-            throw new ValidationError('u256 cannot be negative');
-        }
-        return value;
-    }
-    if (typeof value === 'string') {
-        return parseNumericString(value);
-    }
-    throw new ValidationError(`unsupported numeric type: ${typeof value}`);
-}
-function serializeU256(value) {
-    return `0x${parseU256(value).toString(16)}`;
-}
-function hexFromBytes(bytes) {
-    return `0x${Buffer.from(bytes).toString('hex')}`;
-}

package/dist/src/validation.d.ts

@@ -1,32 +0,0 @@
-import { type Hex } from 'viem';
-import { PaymentGuaranteeRequestClaims, PaymentGuaranteeRequestClaimsV2 } from './models';
-/** Binding domain string used as a prefix when hashing validation subjects. */
-export declare const VALIDATION_SUBJECT_BINDING_DOMAIN = "4MICA_VALIDATION_SUBJECT_V1";
-/** Binding domain string used as a prefix when hashing validation requests. */
-export declare const VALIDATION_REQUEST_BINDING_DOMAIN = "4MICA_VALIDATION_REQUEST_V2";
-/**
- * Compute the `validationSubjectHash` for a V2 payment guarantee request.
- *
- * Binds the payment subject (tab, user, recipient, amount, asset, timestamp) to
- * a keccak256 hash prefixed by {@link VALIDATION_SUBJECT_BINDING_DOMAIN} so that
- * on-chain validators can verify which payment the validation refers to.
- *
- * @param claims - V1 base claims (the subject fields are the same for V1 and V2).
- * @returns 32-byte keccak256 hash as a `0x`-prefixed hex string.
- */
-export declare function computeValidationSubjectHash(claims: PaymentGuaranteeRequestClaims): Hex;
-/**
- * Compute the `validationRequestHash` for a V2 payment guarantee request.
- *
- * Binds the full validation policy (chain, registry, validator, score threshold,
- * subject hash, required tag, job hash) to a keccak256 hash prefixed by
- * {@link VALIDATION_REQUEST_BINDING_DOMAIN}. This hash is included in the V2 claims
- * that are BLS-signed by the core service, allowing on-chain verification that the
- * validation policy was not tampered with.
- *
- * @param claims - V2 claims with all validation policy fields populated.
- *   The `validationSubjectHash` field must already be computed via
- *   {@link computeValidationSubjectHash} before calling this function.
- * @returns 32-byte keccak256 hash as a `0x`-prefixed hex string.
- */
-export declare function computeValidationRequestHash(claims: PaymentGuaranteeRequestClaimsV2): Hex;

package/dist/src/validation.js

@@ -1,84 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.VALIDATION_REQUEST_BINDING_DOMAIN = exports.VALIDATION_SUBJECT_BINDING_DOMAIN = void 0;
-exports.computeValidationSubjectHash = computeValidationSubjectHash;
-exports.computeValidationRequestHash = computeValidationRequestHash;
-const viem_1 = require("viem");
-const utils_1 = require("./utils");
-/** Binding domain string used as a prefix when hashing validation subjects. */
-exports.VALIDATION_SUBJECT_BINDING_DOMAIN = '4MICA_VALIDATION_SUBJECT_V1';
-/** Binding domain string used as a prefix when hashing validation requests. */
-exports.VALIDATION_REQUEST_BINDING_DOMAIN = '4MICA_VALIDATION_REQUEST_V2';
-/**
- * Compute the `validationSubjectHash` for a V2 payment guarantee request.
- *
- * Binds the payment subject (tab, user, recipient, amount, asset, timestamp) to
- * a keccak256 hash prefixed by {@link VALIDATION_SUBJECT_BINDING_DOMAIN} so that
- * on-chain validators can verify which payment the validation refers to.
- *
- * @param claims - V1 base claims (the subject fields are the same for V1 and V2).
- * @returns 32-byte keccak256 hash as a `0x`-prefixed hex string.
- */
-function computeValidationSubjectHash(claims) {
-    const bindingDomain = (0, viem_1.keccak256)(new TextEncoder().encode(exports.VALIDATION_SUBJECT_BINDING_DOMAIN));
-    const encoded = (0, viem_1.encodeAbiParameters)([
-        { type: 'bytes32' },
-        { type: 'uint256' },
-        { type: 'uint256' },
-        { type: 'address' },
-        { type: 'address' },
-        { type: 'uint256' },
-        { type: 'address' },
-        { type: 'uint64' },
-    ], [
-        bindingDomain,
-        claims.tabId,
-        claims.reqId,
-        claims.userAddress,
-        claims.recipientAddress,
-        claims.amount,
-        claims.assetAddress,
-        BigInt(claims.timestamp),
-    ]);
-    return (0, viem_1.keccak256)(encoded);
-}
-/**
- * Compute the `validationRequestHash` for a V2 payment guarantee request.
- *
- * Binds the full validation policy (chain, registry, validator, score threshold,
- * subject hash, required tag, job hash) to a keccak256 hash prefixed by
- * {@link VALIDATION_REQUEST_BINDING_DOMAIN}. This hash is included in the V2 claims
- * that are BLS-signed by the core service, allowing on-chain verification that the
- * validation policy was not tampered with.
- *
- * @param claims - V2 claims with all validation policy fields populated.
- *   The `validationSubjectHash` field must already be computed via
- *   {@link computeValidationSubjectHash} before calling this function.
- * @returns 32-byte keccak256 hash as a `0x`-prefixed hex string.
- */
-function computeValidationRequestHash(claims) {
-    const bindingDomain = (0, viem_1.keccak256)(new TextEncoder().encode(exports.VALIDATION_REQUEST_BINDING_DOMAIN));
-    const tagHash = (0, viem_1.keccak256)(new TextEncoder().encode(claims.requiredValidationTag));
-    const encoded = (0, viem_1.encodeAbiParameters)([
-        { type: 'bytes32' },
-        { type: 'uint256' },
-        { type: 'address' },
-        { type: 'address' },
-        { type: 'uint256' },
-        { type: 'bytes32' },
-        { type: 'uint8' },
-        { type: 'bytes32' },
-        { type: 'bytes32' },
-    ], [
-        bindingDomain,
-        BigInt(claims.validationChainId),
-        claims.validationRegistryAddress,
-        claims.validatorAddress,
-        claims.validatorAgentId,
-        (0, utils_1.ensureHexPrefix)(claims.validationSubjectHash),
-        claims.minValidationScore,
-        tagHash,
-        (0, utils_1.ensureHexPrefix)(claims.jobHash),
-    ]);
-    return (0, viem_1.keccak256)(encoded);
-}

package/dist/src/wallet/cdp.d.ts

@@ -1,13 +0,0 @@
-import { type Account } from 'viem';
-export interface CdpAccountConfig {
-    /** CDP API key ID from the Coinbase Developer Platform dashboard. */
-    apiKeyId: string;
-    /** CDP API key secret from the Coinbase Developer Platform dashboard. */
-    apiKeySecret: string;
-    /** CDP wallet secret — required for account creation/signing operations. */
-    walletSecret: string;
-    /** Idempotency name — getOrCreateAccount always returns the same wallet for a given name. */
-    name: string;
-}
-/** Creates a viem Account backed by a Coinbase CDP MPC wallet (private key never leaves CDP). */
-export declare function createCdpAccount(config: CdpAccountConfig): Promise<Account>;

package/dist/src/wallet/cdp.js

@@ -1,78 +0,0 @@
-"use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
-    Object.defineProperty(o, "default", { enumerable: true, value: v });
-}) : function(o, v) {
-    o["default"] = v;
-});
-var __importStar = (this && this.__importStar) || (function () {
-    var ownKeys = function(o) {
-        ownKeys = Object.getOwnPropertyNames || function (o) {
-            var ar = [];
-            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
-            return ar;
-        };
-        return ownKeys(o);
-    };
-    return function (mod) {
-        if (mod && mod.__esModule) return mod;
-        var result = {};
-        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
-        __setModuleDefault(result, mod);
-        return result;
-    };
-})();
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.createCdpAccount = createCdpAccount;
-const viem_1 = require("viem");
-const accounts_1 = require("viem/accounts");
-/** Creates a viem Account backed by a Coinbase CDP MPC wallet (private key never leaves CDP). */
-async function createCdpAccount(config) {
-    const { CdpClient } = await Promise.resolve().then(() => __importStar(require('@coinbase/cdp-sdk')));
-    const cdp = new CdpClient({
-        apiKeyId: config.apiKeyId,
-        apiKeySecret: config.apiKeySecret,
-        walletSecret: config.walletSecret,
-    });
-    const evmAccount = await cdp.evm.getOrCreateAccount({ name: config.name });
-    const address = evmAccount.address;
-    async function signMessage({ message }) {
-        if (typeof message === 'string') {
-            // CDP's signMessage applies the EIP-191 prefix internally.
-            const result = await cdp.evm.signMessage({ address, message });
-            return result.signature;
-        }
-        const hash = (0, viem_1.hashMessage)(message);
-        const result = await cdp.evm.signHash({ address, hash });
-        return result.signature;
-    }
-    async function signTypedData(parameters) {
-        // Always hash locally with viem (guaranteed correct EIP-712 encoding including
-        // non-standard types like uint64) and sign only the hash via CDP.
-        // CDP's native signTypedData can silently produce a wrong hash for custom types,
-        // which would pass without error but fail signature verification on the core side.
-        const hash = (0, viem_1.hashTypedData)(parameters);
-        const result = await cdp.evm.signHash({ address, hash });
-        return result.signature;
-    }
-    async function signTransaction(transaction, options) {
-        const serializer = options?.serializer ?? viem_1.serializeTransaction;
-        const hash = (0, viem_1.keccak256)(serializer(transaction));
-        const result = await cdp.evm.signHash({ address, hash });
-        const { r, s, yParity } = (0, viem_1.hexToSignature)(result.signature);
-        return serializer(transaction, { r, s, yParity });
-    }
-    // viem's signTypedData generic cannot be satisfied by a hand-rolled adapter without casting — same pattern as hdKeyToAccount.
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any
-    return (0, accounts_1.toAccount)({ address, signMessage, signTypedData, signTransaction });
-}

package/dist/src/wallet/index.d.ts

@@ -1,2 +0,0 @@
-export { createCdpAccount } from './cdp';
-export type { CdpAccountConfig } from './cdp';

package/dist/src/wallet/index.js

@@ -1,5 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.createCdpAccount = void 0;
-var cdp_1 = require("./cdp");
-Object.defineProperty(exports, "createCdpAccount", { enumerable: true, get: function () { return cdp_1.createCdpAccount; } });