@stablechain/sdk 1.0.3 → 1.0.5

package/dist/chunk-VS6GBRDF.js

@@ -0,0 +1,665 @@
+// src/services/erc3009/abi.ts
+var ERC3009_ABI = [
+  {
+    type: "function",
+    name: "transferWithAuthorization",
+    stateMutability: "nonpayable",
+    inputs: [
+      { name: "from", type: "address" },
+      { name: "to", type: "address" },
+      { name: "value", type: "uint256" },
+      { name: "validAfter", type: "uint256" },
+      { name: "validBefore", type: "uint256" },
+      { name: "nonce", type: "bytes32" },
+      { name: "v", type: "uint8" },
+      { name: "r", type: "bytes32" },
+      { name: "s", type: "bytes32" }
+    ],
+    outputs: []
+  },
+  {
+    type: "function",
+    name: "receiveWithAuthorization",
+    stateMutability: "nonpayable",
+    inputs: [
+      { name: "from", type: "address" },
+      { name: "to", type: "address" },
+      { name: "value", type: "uint256" },
+      { name: "validAfter", type: "uint256" },
+      { name: "validBefore", type: "uint256" },
+      { name: "nonce", type: "bytes32" },
+      { name: "v", type: "uint8" },
+      { name: "r", type: "bytes32" },
+      { name: "s", type: "bytes32" }
+    ],
+    outputs: []
+  },
+  {
+    type: "function",
+    name: "cancelAuthorization",
+    stateMutability: "nonpayable",
+    inputs: [
+      { name: "authorizer", type: "address" },
+      { name: "nonce", type: "bytes32" },
+      { name: "v", type: "uint8" },
+      { name: "r", type: "bytes32" },
+      { name: "s", type: "bytes32" }
+    ],
+    outputs: []
+  },
+  {
+    type: "function",
+    name: "authorizationState",
+    stateMutability: "view",
+    inputs: [
+      { name: "authorizer", type: "address" },
+      { name: "nonce", type: "bytes32" }
+    ],
+    outputs: [{ name: "", type: "bool" }]
+  },
+  {
+    type: "function",
+    name: "balanceOf",
+    stateMutability: "view",
+    inputs: [{ name: "account", type: "address" }],
+    outputs: [{ name: "", type: "uint256" }]
+  },
+  {
+    type: "event",
+    name: "AuthorizationUsed",
+    anonymous: false,
+    inputs: [
+      { name: "authorizer", type: "address", indexed: true },
+      { name: "nonce", type: "bytes32", indexed: true }
+    ]
+  },
+  {
+    type: "function",
+    name: "eip712Domain",
+    stateMutability: "view",
+    inputs: [],
+    outputs: [
+      { name: "fields", type: "bytes1" },
+      { name: "name", type: "string" },
+      { name: "version", type: "string" },
+      { name: "chainId", type: "uint256" },
+      { name: "verifyingContract", type: "address" },
+      { name: "salt", type: "bytes32" },
+      { name: "extensions", type: "uint256[]" }
+    ]
+  },
+  {
+    type: "function",
+    name: "name",
+    stateMutability: "view",
+    inputs: [],
+    outputs: [{ name: "", type: "string" }]
+  }
+];
+var AUTHORIZATION_FIELDS = [
+  { name: "from", type: "address" },
+  { name: "to", type: "address" },
+  { name: "value", type: "uint256" },
+  { name: "validAfter", type: "uint256" },
+  { name: "validBefore", type: "uint256" },
+  { name: "nonce", type: "bytes32" }
+];
+var TRANSFER_WITH_AUTHORIZATION_TYPES = {
+  TransferWithAuthorization: AUTHORIZATION_FIELDS
+};
+var RECEIVE_WITH_AUTHORIZATION_TYPES = {
+  ReceiveWithAuthorization: AUTHORIZATION_FIELDS
+};
+var CANCEL_AUTHORIZATION_TYPES = {
+  CancelAuthorization: [
+    { name: "authorizer", type: "address" },
+    { name: "nonce", type: "bytes32" }
+  ]
+};
+
+// src/services/erc3009/signAuthorization.ts
+import { signTypedData } from "viem/actions";
+
+// src/constants.ts
+var STABLE_USDT_ADDRESS = "0x779ded0c9e1022225f8e0630b35a9b54be713736";
+var STABLE_VAULT_ADDRESS = "0xb7Df8db22A5DBBFA9ebeb94b3910aec6a4f05c08";
+
+// src/errors.ts
+import { BaseError } from "viem";
+var StableError = class extends BaseError {
+};
+var StableValidationError = class extends StableError {
+  constructor(field, value, reason, opts) {
+    super(reason, {
+      name: "StableValidationError",
+      cause: opts?.cause,
+      metaMessages: [`Field: ${field}`, `Value: ${formatValue(value)}`]
+    });
+    this.field = field;
+    this.value = value;
+  }
+};
+var StableQuoteError = class extends StableError {
+  constructor(args) {
+    const meta = [`Provider: ${args.provider}`];
+    if (args.httpStatus !== void 0)
+      meta.push(`HTTP status: ${args.httpStatus}`);
+    if (args.providerCode) meta.push(`Provider code: ${args.providerCode}`);
+    super(args.shortMessage, {
+      name: "StableQuoteError",
+      cause: args.cause,
+      metaMessages: meta
+    });
+    this.provider = args.provider;
+    this.httpStatus = args.httpStatus;
+    this.providerCode = args.providerCode;
+    this.body = args.body;
+  }
+};
+var StableTransactionError = class extends StableError {
+  constructor(args) {
+    const meta = [`Phase: ${args.phase}`];
+    if (args.chainId !== void 0) meta.push(`Chain ID: ${args.chainId}`);
+    if (args.txHash) meta.push(`Tx hash: ${args.txHash}`);
+    if (args.revertReason) meta.push(`Revert reason: ${args.revertReason}`);
+    super(args.shortMessage, {
+      name: "StableTransactionError",
+      cause: args.cause,
+      metaMessages: meta
+    });
+    this.phase = args.phase;
+    this.txHash = args.txHash;
+    this.chainId = args.chainId;
+    this.revertReason = args.revertReason;
+  }
+};
+var StableNetworkError = class extends StableError {
+  constructor(args) {
+    super(args.shortMessage, {
+      name: "StableNetworkError",
+      cause: args.cause,
+      metaMessages: args.url ? [`URL: ${args.url}`] : void 0
+    });
+    this.url = args.url;
+  }
+};
+var StableBulkError = class extends StableError {
+  constructor(args) {
+    super(args.shortMessage, { name: "StableBulkError" });
+    this.results = args.results;
+    this.succeeded = args.succeeded;
+    this.failed = args.failed;
+  }
+};
+function formatValue(v) {
+  if (typeof v === "bigint") return `${v}n`;
+  if (typeof v === "string") return JSON.stringify(v);
+  if (v === null) return "null";
+  if (v === void 0) return "undefined";
+  try {
+    return JSON.stringify(v);
+  } catch {
+    return String(v);
+  }
+}
+
+// src/services/erc3009/shared.ts
+import {
+  isAddress,
+  parseSignature,
+  size
+} from "viem";
+import { generatePrivateKey } from "viem/accounts";
+import { getChainId, readContract } from "viem/actions";
+var ZERO_ADDRESS = "0x0000000000000000000000000000000000000000";
+function randomNonce() {
+  return generatePrivateKey();
+}
+function splitSignature(signature) {
+  const { r, s, v, yParity } = parseSignature(signature);
+  return { r, s, v: v !== void 0 ? Number(v) : (yParity ?? 0) + 27 };
+}
+function resolveSigner(client, account) {
+  const signer = account ?? client.account;
+  if (!signer) {
+    throw new StableValidationError(
+      "signer",
+      void 0,
+      "erc3009: requires a signer \u2014 pass `account` or configure one on the client"
+    );
+  }
+  return signer;
+}
+function signerAddress(signer) {
+  return typeof signer === "string" ? signer : signer.address;
+}
+async function resolveDomain(client, token, overrides) {
+  const chainId = overrides?.chainId ?? client.chain?.id ?? await getChainId(client);
+  const verifyingContract = overrides?.verifyingContract ?? token;
+  if (overrides?.name !== void 0 && overrides?.version !== void 0) {
+    return {
+      name: overrides.name,
+      version: overrides.version,
+      chainId,
+      verifyingContract
+    };
+  }
+  try {
+    const res = await readContract(client, {
+      address: token,
+      abi: ERC3009_ABI,
+      functionName: "eip712Domain"
+    });
+    return {
+      name: overrides?.name ?? res[1],
+      version: overrides?.version ?? res[2],
+      chainId,
+      verifyingContract
+    };
+  } catch {
+    const name = overrides?.name ?? await readContract(client, {
+      address: token,
+      abi: ERC3009_ABI,
+      functionName: "name"
+    });
+    return {
+      name,
+      version: overrides?.version ?? "1",
+      chainId,
+      verifyingContract
+    };
+  }
+}
+function validateAuthorizationParams(params) {
+  if (!isAddress(params.from)) {
+    throw new StableValidationError(
+      "from",
+      params.from,
+      `erc3009: invalid sender address "${params.from}"`
+    );
+  }
+  if (!isAddress(params.to) || params.to === ZERO_ADDRESS) {
+    throw new StableValidationError(
+      "to",
+      params.to,
+      `erc3009: invalid recipient address "${params.to}"`
+    );
+  }
+  if (params.value <= 0n) {
+    throw new StableValidationError(
+      "value",
+      params.value,
+      "erc3009: value must be a positive bigint (token smallest unit)"
+    );
+  }
+  if (params.validBefore <= params.validAfter) {
+    throw new StableValidationError(
+      "validBefore",
+      params.validBefore,
+      "erc3009: validBefore must be greater than validAfter"
+    );
+  }
+  validateNonce(params.nonce);
+}
+function validateNonce(nonce) {
+  if (!/^0x[0-9a-fA-F]*$/.test(nonce) || size(nonce) !== 32) {
+    throw new StableValidationError(
+      "nonce",
+      nonce,
+      "erc3009: nonce must be a 32-byte hex value"
+    );
+  }
+}
+
+// src/services/erc3009/signAuthorization.ts
+async function signAuthorization(client, parameters, primaryType, types) {
+  const token = parameters.token ?? STABLE_USDT_ADDRESS;
+  const signer = resolveSigner(client, parameters.account);
+  const authorization = {
+    from: parameters.from ?? signerAddress(signer),
+    to: parameters.to,
+    value: parameters.value,
+    validAfter: parameters.validAfter ?? 0n,
+    validBefore: parameters.validBefore,
+    nonce: parameters.nonce ?? randomNonce()
+  };
+  validateAuthorizationParams(authorization);
+  const domain = await resolveDomain(client, token, parameters.domain);
+  let signature;
+  try {
+    signature = await signTypedData(client, {
+      account: signer,
+      domain,
+      types,
+      primaryType,
+      message: authorization
+    });
+  } catch (err) {
+    throw new StableTransactionError({
+      phase: "sign",
+      shortMessage: "erc3009: wallet rejected or failed to sign the authorization",
+      chainId: domain.chainId === void 0 ? void 0 : Number(domain.chainId),
+      cause: err
+    });
+  }
+  return { authorization, signature, ...splitSignature(signature) };
+}
+
+// src/services/erc3009/signTransferAuthorization.ts
+function signTransferAuthorization(client, parameters) {
+  return signAuthorization(
+    client,
+    parameters,
+    "TransferWithAuthorization",
+    TRANSFER_WITH_AUTHORIZATION_TYPES
+  );
+}
+
+// src/services/erc3009/signReceiveAuthorization.ts
+function signReceiveAuthorization(client, parameters) {
+  return signAuthorization(
+    client,
+    parameters,
+    "ReceiveWithAuthorization",
+    RECEIVE_WITH_AUTHORIZATION_TYPES
+  );
+}
+
+// src/services/erc3009/submit.ts
+import { writeContract } from "viem/actions";
+async function submitAuthorizationTx(client, token, functionName, signed) {
+  const signer = resolveSigner(client, void 0);
+  const { authorization: a, v, r, s } = signed;
+  try {
+    return await writeContract(client, {
+      address: token,
+      abi: ERC3009_ABI,
+      functionName,
+      args: [
+        a.from,
+        a.to,
+        a.value,
+        a.validAfter,
+        a.validBefore,
+        a.nonce,
+        v,
+        r,
+        s
+      ],
+      account: signer,
+      chain: client.chain
+    });
+  } catch (err) {
+    throw new StableTransactionError({
+      phase: "send",
+      shortMessage: `erc3009: ${functionName} transaction failed`,
+      chainId: client.chain?.id,
+      cause: err
+    });
+  }
+}
+
+// src/services/erc3009/transferWithAuthorization.ts
+async function transferWithAuthorization(client, parameters) {
+  const token = parameters.token ?? STABLE_USDT_ADDRESS;
+  const signed = "signed" in parameters ? parameters.signed : await signTransferAuthorization(client, parameters);
+  return submitAuthorizationTx(
+    client,
+    token,
+    "transferWithAuthorization",
+    signed
+  );
+}
+
+// src/services/erc3009/receiveWithAuthorization.ts
+async function receiveWithAuthorization(client, parameters) {
+  const token = parameters.token ?? STABLE_USDT_ADDRESS;
+  const signed = "signed" in parameters ? parameters.signed : await signReceiveAuthorization(client, parameters);
+  const caller = signerAddress(resolveSigner(client, void 0));
+  if (caller.toLowerCase() !== signed.authorization.to.toLowerCase()) {
+    throw new StableValidationError(
+      "caller",
+      caller,
+      `erc3009: receiveWithAuthorization must be submitted by the recipient (to=${signed.authorization.to})`
+    );
+  }
+  return submitAuthorizationTx(
+    client,
+    token,
+    "receiveWithAuthorization",
+    signed
+  );
+}
+
+// src/services/erc3009/cancelAuthorization.ts
+import { signTypedData as signTypedData2, writeContract as writeContract2 } from "viem/actions";
+async function cancelAuthorization(client, parameters) {
+  const token = parameters.token ?? STABLE_USDT_ADDRESS;
+  const signer = resolveSigner(client, parameters.account);
+  const authorizer = parameters.authorizer ?? signerAddress(signer);
+  validateNonce(parameters.nonce);
+  const domain = await resolveDomain(client, token, parameters.domain);
+  const message = { authorizer, nonce: parameters.nonce };
+  let signature;
+  try {
+    signature = await signTypedData2(client, {
+      account: signer,
+      domain,
+      types: CANCEL_AUTHORIZATION_TYPES,
+      primaryType: "CancelAuthorization",
+      message
+    });
+  } catch (err) {
+    throw new StableTransactionError({
+      phase: "sign",
+      shortMessage: "erc3009: wallet rejected or failed to sign the cancellation",
+      chainId: domain.chainId === void 0 ? void 0 : Number(domain.chainId),
+      cause: err
+    });
+  }
+  const { v, r, s } = splitSignature(signature);
+  try {
+    return await writeContract2(client, {
+      address: token,
+      abi: ERC3009_ABI,
+      functionName: "cancelAuthorization",
+      args: [authorizer, parameters.nonce, v, r, s],
+      account: signer,
+      chain: client.chain
+    });
+  } catch (err) {
+    throw new StableTransactionError({
+      phase: "send",
+      shortMessage: "erc3009: cancelAuthorization transaction failed",
+      chainId: client.chain?.id,
+      cause: err
+    });
+  }
+}
+
+// src/services/erc3009/prepareTransferWithAuthorization.ts
+import { encodeFunctionData } from "viem";
+import { getChainId as getChainId2 } from "viem/actions";
+async function prepareTransferWithAuthorization(client, parameters) {
+  const token = parameters.token ?? STABLE_USDT_ADDRESS;
+  const signed = await signTransferAuthorization(client, parameters);
+  const { authorization: a, v, r, s } = signed;
+  const data = encodeFunctionData({
+    abi: ERC3009_ABI,
+    functionName: "transferWithAuthorization",
+    args: [
+      a.from,
+      a.to,
+      a.value,
+      a.validAfter,
+      a.validBefore,
+      a.nonce,
+      v,
+      r,
+      s
+    ]
+  });
+  const chainId = client.chain?.id ?? await getChainId2(client);
+  return { to: token, data, value: 0n, chainId, signed };
+}
+
+// src/services/erc3009/verifyAuthorization.ts
+import { recoverTypedDataAddress } from "viem";
+import { getBlock, readContract as readContract2, simulateContract } from "viem/actions";
+async function verifyAuthorization(client, parameters) {
+  const token = parameters.token ?? STABLE_USDT_ADDRESS;
+  const primaryType = parameters.primaryType ?? "TransferWithAuthorization";
+  const isReceive = primaryType === "ReceiveWithAuthorization";
+  const types = isReceive ? RECEIVE_WITH_AUTHORIZATION_TYPES : TRANSFER_WITH_AUTHORIZATION_TYPES;
+  const { authorization: a, signature, v, r, s } = parameters.signed;
+  const reasons = [];
+  const domain = await resolveDomain(client, token, parameters.domain);
+  let signer;
+  try {
+    signer = await recoverTypedDataAddress({
+      domain,
+      types,
+      primaryType,
+      message: a,
+      signature
+      // biome-ignore lint/suspicious/noExplicitAny: dynamic primaryType/types
+    });
+    if (signer.toLowerCase() !== a.from.toLowerCase()) {
+      reasons.push("signer_mismatch");
+    }
+  } catch {
+    reasons.push("invalid_signature");
+  }
+  const used = await readContract2(client, {
+    address: token,
+    abi: ERC3009_ABI,
+    functionName: "authorizationState",
+    args: [a.from, a.nonce]
+  });
+  if (used) reasons.push("already_used");
+  const now = parameters.now ?? (await getBlock(client, { blockTag: "latest" })).timestamp;
+  const margin = BigInt(parameters.expiryMarginSeconds ?? 0);
+  if (a.validAfter > now) reasons.push("not_yet_valid");
+  if (a.validBefore <= now) reasons.push("expired");
+  else if (a.validBefore <= now + margin) reasons.push("expiring_soon");
+  const balance = await readContract2(client, {
+    address: token,
+    abi: ERC3009_ABI,
+    functionName: "balanceOf",
+    args: [a.from]
+  });
+  let shortfall;
+  if (balance < a.value) {
+    reasons.push("insufficient_funds");
+    shortfall = a.value - balance;
+  }
+  let revertReason;
+  try {
+    await simulateContract(client, {
+      address: token,
+      abi: ERC3009_ABI,
+      functionName: isReceive ? "receiveWithAuthorization" : "transferWithAuthorization",
+      args: [
+        a.from,
+        a.to,
+        a.value,
+        a.validAfter,
+        a.validBefore,
+        a.nonce,
+        v,
+        r,
+        s
+      ],
+      account: a.to
+    });
+  } catch (err) {
+    reasons.push("would_revert");
+    revertReason = err.shortMessage ?? err.message;
+  }
+  return {
+    ok: reasons.length === 0,
+    reasons,
+    signer,
+    balance,
+    shortfall,
+    revertReason
+  };
+}
+
+// src/services/erc3009/getAuthorizationState.ts
+import { readContract as readContract3 } from "viem/actions";
+function getAuthorizationState(client, parameters) {
+  validateNonce(parameters.nonce);
+  return readContract3(client, {
+    address: parameters.token ?? STABLE_USDT_ADDRESS,
+    abi: ERC3009_ABI,
+    functionName: "authorizationState",
+    args: [parameters.authorizer, parameters.nonce]
+  });
+}
+
+// src/services/erc3009/getAuthorizationUsage.ts
+import { getLogs } from "viem/actions";
+var AUTHORIZATION_USED_EVENT = {
+  type: "event",
+  name: "AuthorizationUsed",
+  anonymous: false,
+  inputs: [
+    { name: "authorizer", type: "address", indexed: true },
+    { name: "nonce", type: "bytes32", indexed: true }
+  ]
+};
+async function getAuthorizationUsage(client, parameters) {
+  validateNonce(parameters.nonce);
+  const logs = await getLogs(client, {
+    address: parameters.token ?? STABLE_USDT_ADDRESS,
+    event: AUTHORIZATION_USED_EVENT,
+    args: { authorizer: parameters.authorizer, nonce: parameters.nonce },
+    fromBlock: parameters.fromBlock ?? "earliest",
+    toBlock: parameters.toBlock ?? "latest"
+  });
+  const hit = logs.at(-1);
+  if (!hit) return { used: false };
+  return {
+    used: true,
+    txHash: hit.transactionHash ?? void 0,
+    blockNumber: hit.blockNumber ?? void 0
+  };
+}
+
+// src/services/erc3009/decorator.ts
+function erc3009Actions(client) {
+  return {
+    signTransferAuthorization: (p) => signTransferAuthorization(client, p),
+    signReceiveAuthorization: (p) => signReceiveAuthorization(client, p),
+    transferWithAuthorization: (p) => transferWithAuthorization(client, p),
+    receiveWithAuthorization: (p) => receiveWithAuthorization(client, p),
+    cancelAuthorization: (p) => cancelAuthorization(client, p),
+    prepareTransferWithAuthorization: (p) => prepareTransferWithAuthorization(client, p),
+    verifyAuthorization: (p) => verifyAuthorization(client, p),
+    getAuthorizationState: (p) => getAuthorizationState(client, p),
+    getAuthorizationUsage: (p) => getAuthorizationUsage(client, p)
+  };
+}
+
+export {
+  StableError,
+  StableValidationError,
+  StableQuoteError,
+  StableTransactionError,
+  StableNetworkError,
+  StableBulkError,
+  ERC3009_ABI,
+  STABLE_USDT_ADDRESS,
+  STABLE_VAULT_ADDRESS,
+  signTransferAuthorization,
+  signReceiveAuthorization,
+  transferWithAuthorization,
+  receiveWithAuthorization,
+  cancelAuthorization,
+  prepareTransferWithAuthorization,
+  verifyAuthorization,
+  getAuthorizationState,
+  getAuthorizationUsage,
+  erc3009Actions
+};

package/dist/erc3009.cjs

@@ -0,0 +1,26 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true});
+
+
+
+
+
+
+
+
+
+
+
+var _chunkQQ26UI3Fcjs = require('./chunk-QQ26UI3F.cjs');
+
+
+
+
+
+
+
+
+
+
+
+
+exports.ERC3009_ABI = _chunkQQ26UI3Fcjs.ERC3009_ABI; exports.cancelAuthorization = _chunkQQ26UI3Fcjs.cancelAuthorization; exports.erc3009Actions = _chunkQQ26UI3Fcjs.erc3009Actions; exports.getAuthorizationState = _chunkQQ26UI3Fcjs.getAuthorizationState; exports.getAuthorizationUsage = _chunkQQ26UI3Fcjs.getAuthorizationUsage; exports.prepareTransferWithAuthorization = _chunkQQ26UI3Fcjs.prepareTransferWithAuthorization; exports.receiveWithAuthorization = _chunkQQ26UI3Fcjs.receiveWithAuthorization; exports.signReceiveAuthorization = _chunkQQ26UI3Fcjs.signReceiveAuthorization; exports.signTransferAuthorization = _chunkQQ26UI3Fcjs.signTransferAuthorization; exports.transferWithAuthorization = _chunkQQ26UI3Fcjs.transferWithAuthorization; exports.verifyAuthorization = _chunkQQ26UI3Fcjs.verifyAuthorization;