@stablechain/sdk 1.0.4 → 1.0.5

package/dist/chunk-QQ26UI3F.cjs

@@ -0,0 +1,665 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _nullishCoalesce(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return rhsFn(); } } async function _asyncNullishCoalesce(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return await rhsFn(); } } function _optionalChain(ops) { let lastAccessLHS = undefined; let value = ops[0]; let i = 1; while (i < ops.length) { const op = ops[i]; const fn = ops[i + 1]; i += 2; if ((op === 'optionalAccess' || op === 'optionalCall') && value == null) { return undefined; } if (op === 'access' || op === 'optionalAccess') { lastAccessLHS = value; value = fn(value); } else if (op === 'call' || op === 'optionalCall') { value = fn((...args) => value.call(lastAccessLHS, ...args)); lastAccessLHS = undefined; } } return value; } async function _asyncOptionalChain(ops) { let lastAccessLHS = undefined; let value = ops[0]; let i = 1; while (i < ops.length) { const op = ops[i]; const fn = ops[i + 1]; i += 2; if ((op === 'optionalAccess' || op === 'optionalCall') && value == null) { return undefined; } if (op === 'access' || op === 'optionalAccess') { lastAccessLHS = value; value = await fn(value); } else if (op === 'call' || op === 'optionalCall') { value = await fn((...args) => value.call(lastAccessLHS, ...args)); lastAccessLHS = undefined; } } return value; }// 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
+var _actions = require('viem/actions');
+
+// src/constants.ts
+var STABLE_USDT_ADDRESS = "0x779ded0c9e1022225f8e0630b35a9b54be713736";
+var STABLE_VAULT_ADDRESS = "0xb7Df8db22A5DBBFA9ebeb94b3910aec6a4f05c08";
+
+// src/errors.ts
+var _viem = require('viem');
+var StableError = class extends _viem.BaseError {
+};
+var StableValidationError = class extends StableError {
+  constructor(field, value, reason, opts) {
+    super(reason, {
+      name: "StableValidationError",
+      cause: _optionalChain([opts, 'optionalAccess', _ => _.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 (e) {
+    return String(v);
+  }
+}
+
+// src/services/erc3009/shared.ts
+
+
+
+
+
+var _accounts = require('viem/accounts');
+
+var ZERO_ADDRESS = "0x0000000000000000000000000000000000000000";
+function randomNonce() {
+  return _accounts.generatePrivateKey.call(void 0, );
+}
+function splitSignature(signature) {
+  const { r, s, v, yParity } = _viem.parseSignature.call(void 0, signature);
+  return { r, s, v: v !== void 0 ? Number(v) : (_nullishCoalesce(yParity, () => ( 0))) + 27 };
+}
+function resolveSigner(client, account) {
+  const signer = _nullishCoalesce(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 = await _asyncNullishCoalesce(await _asyncNullishCoalesce(await _asyncOptionalChain([overrides, 'optionalAccess', async _2 => _2.chainId]), async () => ( _optionalChain([client, 'access', _3 => _3.chain, 'optionalAccess', _4 => _4.id]))), async () => ( await _actions.getChainId.call(void 0, client)));
+  const verifyingContract = _nullishCoalesce(_optionalChain([overrides, 'optionalAccess', _5 => _5.verifyingContract]), () => ( token));
+  if (_optionalChain([overrides, 'optionalAccess', _6 => _6.name]) !== void 0 && _optionalChain([overrides, 'optionalAccess', _7 => _7.version]) !== void 0) {
+    return {
+      name: overrides.name,
+      version: overrides.version,
+      chainId,
+      verifyingContract
+    };
+  }
+  try {
+    const res = await _actions.readContract.call(void 0, client, {
+      address: token,
+      abi: ERC3009_ABI,
+      functionName: "eip712Domain"
+    });
+    return {
+      name: _nullishCoalesce(_optionalChain([overrides, 'optionalAccess', _8 => _8.name]), () => ( res[1])),
+      version: _nullishCoalesce(_optionalChain([overrides, 'optionalAccess', _9 => _9.version]), () => ( res[2])),
+      chainId,
+      verifyingContract
+    };
+  } catch (e2) {
+    const name = await _asyncNullishCoalesce(await _asyncOptionalChain([overrides, 'optionalAccess', async _10 => _10.name]), async () => ( await _actions.readContract.call(void 0, client, {
+      address: token,
+      abi: ERC3009_ABI,
+      functionName: "name"
+    })));
+    return {
+      name,
+      version: _nullishCoalesce(_optionalChain([overrides, 'optionalAccess', _11 => _11.version]), () => ( "1")),
+      chainId,
+      verifyingContract
+    };
+  }
+}
+function validateAuthorizationParams(params) {
+  if (!_viem.isAddress.call(void 0, params.from)) {
+    throw new StableValidationError(
+      "from",
+      params.from,
+      `erc3009: invalid sender address "${params.from}"`
+    );
+  }
+  if (!_viem.isAddress.call(void 0, 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) || _viem.size.call(void 0, 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 = _nullishCoalesce(parameters.token, () => ( STABLE_USDT_ADDRESS));
+  const signer = resolveSigner(client, parameters.account);
+  const authorization = {
+    from: _nullishCoalesce(parameters.from, () => ( signerAddress(signer))),
+    to: parameters.to,
+    value: parameters.value,
+    validAfter: _nullishCoalesce(parameters.validAfter, () => ( 0n)),
+    validBefore: parameters.validBefore,
+    nonce: _nullishCoalesce(parameters.nonce, () => ( randomNonce()))
+  };
+  validateAuthorizationParams(authorization);
+  const domain = await resolveDomain(client, token, parameters.domain);
+  let signature;
+  try {
+    signature = await _actions.signTypedData.call(void 0, 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
+
+async function submitAuthorizationTx(client, token, functionName, signed) {
+  const signer = resolveSigner(client, void 0);
+  const { authorization: a, v, r, s } = signed;
+  try {
+    return await _actions.writeContract.call(void 0, 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: _optionalChain([client, 'access', _12 => _12.chain, 'optionalAccess', _13 => _13.id]),
+      cause: err
+    });
+  }
+}
+
+// src/services/erc3009/transferWithAuthorization.ts
+async function transferWithAuthorization(client, parameters) {
+  const token = _nullishCoalesce(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 = _nullishCoalesce(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
+
+async function cancelAuthorization(client, parameters) {
+  const token = _nullishCoalesce(parameters.token, () => ( STABLE_USDT_ADDRESS));
+  const signer = resolveSigner(client, parameters.account);
+  const authorizer = _nullishCoalesce(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 _actions.signTypedData.call(void 0, 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 _actions.writeContract.call(void 0, 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: _optionalChain([client, 'access', _14 => _14.chain, 'optionalAccess', _15 => _15.id]),
+      cause: err
+    });
+  }
+}
+
+// src/services/erc3009/prepareTransferWithAuthorization.ts
+
+
+async function prepareTransferWithAuthorization(client, parameters) {
+  const token = _nullishCoalesce(parameters.token, () => ( STABLE_USDT_ADDRESS));
+  const signed = await signTransferAuthorization(client, parameters);
+  const { authorization: a, v, r, s } = signed;
+  const data = _viem.encodeFunctionData.call(void 0, {
+    abi: ERC3009_ABI,
+    functionName: "transferWithAuthorization",
+    args: [
+      a.from,
+      a.to,
+      a.value,
+      a.validAfter,
+      a.validBefore,
+      a.nonce,
+      v,
+      r,
+      s
+    ]
+  });
+  const chainId = await _asyncNullishCoalesce(await _asyncOptionalChain([client, 'access', async _16 => _16.chain, 'optionalAccess', async _17 => _17.id]), async () => ( await _actions.getChainId.call(void 0, client)));
+  return { to: token, data, value: 0n, chainId, signed };
+}
+
+// src/services/erc3009/verifyAuthorization.ts
+
+
+async function verifyAuthorization(client, parameters) {
+  const token = _nullishCoalesce(parameters.token, () => ( STABLE_USDT_ADDRESS));
+  const primaryType = _nullishCoalesce(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 _viem.recoverTypedDataAddress.call(void 0, {
+      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 (e3) {
+    reasons.push("invalid_signature");
+  }
+  const used = await _actions.readContract.call(void 0, client, {
+    address: token,
+    abi: ERC3009_ABI,
+    functionName: "authorizationState",
+    args: [a.from, a.nonce]
+  });
+  if (used) reasons.push("already_used");
+  const now = await _asyncNullishCoalesce(parameters.now, async () => ( (await _actions.getBlock.call(void 0, client, { blockTag: "latest" })).timestamp));
+  const margin = BigInt(_nullishCoalesce(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 _actions.readContract.call(void 0, 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 _actions.simulateContract.call(void 0, 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 = _nullishCoalesce(err.shortMessage, () => ( err.message));
+  }
+  return {
+    ok: reasons.length === 0,
+    reasons,
+    signer,
+    balance,
+    shortfall,
+    revertReason
+  };
+}
+
+// src/services/erc3009/getAuthorizationState.ts
+
+function getAuthorizationState(client, parameters) {
+  validateNonce(parameters.nonce);
+  return _actions.readContract.call(void 0, client, {
+    address: _nullishCoalesce(parameters.token, () => ( STABLE_USDT_ADDRESS)),
+    abi: ERC3009_ABI,
+    functionName: "authorizationState",
+    args: [parameters.authorizer, parameters.nonce]
+  });
+}
+
+// src/services/erc3009/getAuthorizationUsage.ts
+
+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 _actions.getLogs.call(void 0, client, {
+    address: _nullishCoalesce(parameters.token, () => ( STABLE_USDT_ADDRESS)),
+    event: AUTHORIZATION_USED_EVENT,
+    args: { authorizer: parameters.authorizer, nonce: parameters.nonce },
+    fromBlock: _nullishCoalesce(parameters.fromBlock, () => ( "earliest")),
+    toBlock: _nullishCoalesce(parameters.toBlock, () => ( "latest"))
+  });
+  const hit = logs.at(-1);
+  if (!hit) return { used: false };
+  return {
+    used: true,
+    txHash: _nullishCoalesce(hit.transactionHash, () => ( void 0)),
+    blockNumber: _nullishCoalesce(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)
+  };
+}
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+exports.StableError = StableError; exports.StableValidationError = StableValidationError; exports.StableQuoteError = StableQuoteError; exports.StableTransactionError = StableTransactionError; exports.StableNetworkError = StableNetworkError; exports.StableBulkError = StableBulkError; exports.ERC3009_ABI = ERC3009_ABI; exports.STABLE_USDT_ADDRESS = STABLE_USDT_ADDRESS; exports.STABLE_VAULT_ADDRESS = STABLE_VAULT_ADDRESS; exports.signTransferAuthorization = signTransferAuthorization; exports.signReceiveAuthorization = signReceiveAuthorization; exports.transferWithAuthorization = transferWithAuthorization; exports.receiveWithAuthorization = receiveWithAuthorization; exports.cancelAuthorization = cancelAuthorization; exports.prepareTransferWithAuthorization = prepareTransferWithAuthorization; exports.verifyAuthorization = verifyAuthorization; exports.getAuthorizationState = getAuthorizationState; exports.getAuthorizationUsage = getAuthorizationUsage; exports.erc3009Actions = erc3009Actions;