sta-sdk 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Smart Treasury Account contributors
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,107 @@
+# sta-sdk
+
+TypeScript SDK for the Smart Treasury Account (STA) Soroban contracts:
+`smart_account` custom-authorization (Entry A / Entry B) construction,
+transaction preparation (prepare → simulate → sign → submit → poll), typed
+`#[contractevent]` parsing, and typed state reads (policy version, replay
+nonce, recovery state).
+
+## Install
+
+```sh
+npm install sta-sdk @stellar/stellar-sdk
+```
+
+`@stellar/stellar-sdk` (`>=16.0.0`) is a peer dependency — install it
+yourself so your app controls the version and there is only ever one copy
+of its classes (`Address`, `xdr.ScVal`, ...) loaded.
+
+## Why this SDK hand-encodes calls instead of using generated bindings
+
+The Stellar CLI's `stellar contract bindings typescript` output is pinned
+to whatever `@stellar/stellar-sdk` major was current when it was
+generated. Depending on those generated bindings directly here would force
+every consumer of this SDK onto that exact major, and loading two majors
+of the same runtime classes in one bundle risks `instanceof` mismatches.
+So this package encodes `AuthPayload` structs, call args, and typed reads
+by hand against the contracts' real `#[contracttype]`/`#[contractevent]`
+definitions, verified live — see each module's doc comment for specifics.
+
+## Usage
+
+```ts
+import { TESTNET, prepareTransferPayment, signAndSubmit, readPolicyVersion } from "sta-sdk";
+import { Keypair } from "@stellar/stellar-sdk";
+
+const signer = Keypair.fromSecret(process.env.SIGNER_SECRET!);
+const expectedPolicyVersion = await readPolicyVersion(TESTNET, signer.publicKey());
+
+const tx = await prepareTransferPayment(
+  {
+    net: TESTNET,
+    feeSourceAddress: signer.publicKey(),
+    signerAddress: signer.publicKey(),
+    sign: signer,
+  },
+  {
+    asset: "CASSET...",
+    destination: "GDESTINATION...",
+    amount: 100_0000000n,
+    nonce: BigInt(Date.now()),
+    expectedPolicyVersion,
+  },
+);
+
+const result = await signAndSubmit(TESTNET, tx, signer);
+console.log("ledger:", result.ledger);
+```
+
+See [`examples/`](./examples) for one runnable, documented example per
+flow: transfer, split payment, scheduled payment, and event parsing.
+
+## Modules
+
+| Module | Exports |
+|---|---|
+| `config` | `NetworkConfig`, `TESTNET`, `buildMainnetConfig` |
+| `auth` | `buildSmartAccountAuthEntries`, `buildExecutorAuthEntry`, auth-entry helpers |
+| `payments` | `prepareTransferPayment`, `prepareSplitPayment`, `prepareScheduledPayment`, `prepareCancelScheduledPayment`, `signAndSubmit` |
+| `events` | `parseContractEvent`, `parseContractEvents`, `findEvent` |
+| `state` | typed reads: `AccountStatus`, `ContextRule`, `ScheduledIntent`, `RecoveryRequest`, `WasmHashes` |
+
+## Versioning against a deployment
+
+Each release states which contract deployment it targets. `TESTNET` in
+`config.ts` is pinned to the currently-deployed testnet contract set (see
+that module's doc comment for the source deployment record). Mainnet has
+no deployment yet — `buildMainnetConfig` exists so wiring one in later is
+a config call, not a code change; see its doc comment.
+
+## Known issue — multi-signer context rules
+
+`buildSmartAccountAuthEntries` builds Entry A + Entry B for a single
+required signer. For a context rule with more than one required signer
+(a real M-of-N threshold), calling it once per signer and attaching each
+pair does **not** currently match the documented design (one shared
+Entry A carrying all signers' keys, plus N Entry Bs collected against it).
+Don't rely on multi-signer thresholds through this function until that's
+fixed — see the doc comment on that function.
+
+## Development
+
+```sh
+pnpm install
+pnpm test
+pnpm build
+```
+
+## Publishing
+
+```sh
+npm version <patch|minor|major>
+npm publish
+```
+
+`prepublishOnly` runs typecheck, tests, and build first. CI
+(`.github/workflows/publish.yml`) publishes automatically on a pushed
+`v*` tag, using the `NPM_TOKEN` repository secret.

package/dist/index.cjs

@@ -0,0 +1,498 @@
+'use strict';
+
+var stellarSdk = require('@stellar/stellar-sdk');
+
+// src/config.ts
+var TESTNET = {
+  network: "testnet",
+  rpcUrl: "https://soroban-testnet.stellar.org",
+  networkPassphrase: "Test SDF Network ; September 2015",
+  contracts: {
+    smartAccount: "CD6GY4UUTNPW4TUV7LDL5SELN4BBHJG4KDDT3W6G23DY6XCGM75MULMQ",
+    policyEngine: "CCOP7NRMST5K6TL7FBDMX25LDEPW3DSFBOGBIKVFIDNAAZY7GBMVP3M4",
+    intentRegistry: "CAFIATSIZQSBILZJWVT4PVDXPVITJHLP6LPAVKDRHCA7I7XPZSLTRPUS",
+    recoveryManager: "CCHC4YKVYS3CAZUOUYWYTEMQ6TZDW75WB2BGENUC2CDWDX5RH7NMKZWU",
+    accountFactory: "CAQQTRRYNXIQGFVNCTMTBJDXW3PN7O44KPT7GWCCE4FRKTOHDBCWGUZO",
+    transferAdapter: "CBRYGIR3ORDW5LE6J7AVPSKRNTMRUYHD6FVPHQMJGPQLQ5FQUZ2U6GFH",
+    splitAdapter: "CBQA7UI7QN6RN4IZT7WPDHWTK2OO7J4FH2KMCVJGKMKVFGDURD63UQ7U"
+  }
+};
+var MAINNET_NETWORK_PASSPHRASE = "Public Global Stellar Network ; September 2015";
+var MAINNET_RPC_URL_ENV = "STA_MAINNET_RPC_URL";
+function buildMainnetConfig(contracts, rpcUrl = (typeof process !== "undefined" ? process.env?.[MAINNET_RPC_URL_ENV] : void 0) ?? "") {
+  if (!rpcUrl) {
+    throw new Error(
+      `Mainnet RPC URL not configured -- pass one explicitly to buildMainnetConfig, or set ${MAINNET_RPC_URL_ENV}. SDF hosts no free public mainnet endpoint; see https://developers.stellar.org/docs/data/apis/rpc/providers for ecosystem providers.`
+    );
+  }
+  return {
+    network: "mainnet",
+    rpcUrl,
+    networkPassphrase: MAINNET_NETWORK_PASSPHRASE,
+    contracts
+  };
+}
+var MAINNET = void 0;
+var NETWORKS = {
+  testnet: TESTNET,
+  mainnet: MAINNET
+};
+function structScVal(fields) {
+  return stellarSdk.xdr.ScVal.scvMap(
+    Object.entries(fields).sort(([left], [right]) => left < right ? -1 : left > right ? 1 : 0).map(
+      ([key, val]) => new stellarSdk.xdr.ScMapEntry({
+        key: stellarSdk.xdr.ScVal.scvSymbol(key),
+        val
+      })
+    )
+  );
+}
+
+// src/auth.ts
+function buildInvocation(spec) {
+  const fn = new stellarSdk.xdr.InvokeContractArgs({
+    contractAddress: new stellarSdk.Address(spec.contractId).toScAddress(),
+    functionName: spec.functionName,
+    args: spec.args
+  });
+  const func = stellarSdk.xdr.SorobanAuthorizedFunction.sorobanAuthorizedFunctionTypeContractFn(fn);
+  return new stellarSdk.xdr.SorobanAuthorizedInvocation({
+    function: func,
+    subInvocations: spec.subInvocations ?? []
+  });
+}
+function networkId(networkPassphrase) {
+  return stellarSdk.hash(Buffer.from(networkPassphrase));
+}
+function signaturePayload(invocation, nonce, signatureExpirationLedger, networkPassphrase) {
+  const preimage = stellarSdk.xdr.HashIdPreimage.envelopeTypeSorobanAuthorization(
+    new stellarSdk.xdr.HashIdPreimageSorobanAuthorization({
+      networkId: networkId(networkPassphrase),
+      nonce: stellarSdk.xdr.Int64.fromString(nonce.toString()),
+      signatureExpirationLedger,
+      invocation
+    })
+  );
+  return stellarSdk.hash(preimage.toXDR());
+}
+function randomNonce() {
+  const high = BigInt(Math.floor(Math.random() * 2 ** 30));
+  const low = BigInt(Math.floor(Math.random() * 2 ** 32));
+  return high << 32n | low;
+}
+async function buildClassicAuthEntry(address, invocation, sign, signatureExpirationLedger, networkPassphrase) {
+  const nonce = randomNonce();
+  const unsignedEntry = new stellarSdk.xdr.SorobanAuthorizationEntry({
+    credentials: stellarSdk.xdr.SorobanCredentials.sorobanCredentialsAddress(
+      new stellarSdk.xdr.SorobanAddressCredentials({
+        address: new stellarSdk.Address(address).toScAddress(),
+        nonce: stellarSdk.xdr.Int64.fromString(nonce.toString()),
+        signatureExpirationLedger,
+        signature: stellarSdk.xdr.ScVal.scvVoid()
+      })
+    ),
+    rootInvocation: invocation
+  });
+  return stellarSdk.authorizeEntry(unsignedEntry, sign, signatureExpirationLedger, networkPassphrase);
+}
+function smartAccountAuthPayloadScVal(signerAddress, contextRuleIdsScVal) {
+  const signerKey = stellarSdk.xdr.ScVal.scvVec([
+    stellarSdk.xdr.ScVal.scvSymbol("Delegated"),
+    new stellarSdk.Address(signerAddress).toScVal()
+  ]);
+  const signersMap = stellarSdk.xdr.ScVal.scvMap([
+    new stellarSdk.xdr.ScMapEntry({ key: signerKey, val: stellarSdk.xdr.ScVal.scvBytes(Buffer.alloc(0)) })
+  ]);
+  return structScVal({
+    context_rule_ids: contextRuleIdsScVal,
+    signers: signersMap
+  });
+}
+async function buildSmartAccountAuthEntries(opts) {
+  const contextRuleIds = opts.contextRuleIds ?? [0];
+  const nonceA = randomNonce();
+  const sigPayloadA = signaturePayload(
+    opts.rootInvocation,
+    nonceA,
+    opts.signatureExpirationLedger,
+    opts.networkPassphrase
+  );
+  const contextRuleIdsScVal = stellarSdk.xdr.ScVal.scvVec(
+    contextRuleIds.map((id) => stellarSdk.xdr.ScVal.scvU32(id))
+  );
+  const authDigest = stellarSdk.hash(
+    Buffer.concat([Buffer.from(sigPayloadA), Buffer.from(contextRuleIdsScVal.toXDR())])
+  );
+  const entryA = new stellarSdk.xdr.SorobanAuthorizationEntry({
+    credentials: stellarSdk.xdr.SorobanCredentials.sorobanCredentialsAddress(
+      new stellarSdk.xdr.SorobanAddressCredentials({
+        address: new stellarSdk.Address(opts.smartAccountId).toScAddress(),
+        nonce: stellarSdk.xdr.Int64.fromString(nonceA.toString()),
+        signatureExpirationLedger: opts.signatureExpirationLedger,
+        signature: smartAccountAuthPayloadScVal(opts.signerAddress, contextRuleIdsScVal)
+      })
+    ),
+    rootInvocation: opts.rootInvocation
+  });
+  const nestedInvocation = buildInvocation({
+    contractId: opts.smartAccountId,
+    functionName: "__check_auth",
+    args: [stellarSdk.xdr.ScVal.scvBytes(authDigest)]
+  });
+  const entryB = await buildClassicAuthEntry(
+    opts.signerAddress,
+    nestedInvocation,
+    opts.sign,
+    opts.signatureExpirationLedger,
+    opts.networkPassphrase
+  );
+  return [entryA, entryB];
+}
+async function buildExecutorAuthEntry(opts) {
+  const invocation = buildInvocation({
+    contractId: opts.intentRegistryId,
+    functionName: "mark_child_executed",
+    args: [stellarSdk.xdr.ScVal.scvBytes(opts.intentId), stellarSdk.xdr.ScVal.scvU32(opts.childSequence)]
+  });
+  return buildClassicAuthEntry(
+    opts.executorAddress,
+    invocation,
+    opts.sign,
+    opts.signatureExpirationLedger,
+    opts.networkPassphrase
+  );
+}
+var DEFAULT_EXPIRATION_WINDOW_LEDGERS = 100;
+var POLL_INTERVAL_MS = 3e3;
+var MAX_POLL_ATTEMPTS = 40;
+function addressScVal(id) {
+  return new stellarSdk.Address(id).toScVal();
+}
+function i128ScVal(value) {
+  return stellarSdk.nativeToScVal(value, { type: "i128" });
+}
+function u32ScVal(value) {
+  return stellarSdk.nativeToScVal(value, { type: "u32" });
+}
+function u64ScVal(value) {
+  return stellarSdk.nativeToScVal(value, { type: "u64" });
+}
+function boolScVal(value) {
+  return stellarSdk.nativeToScVal(value);
+}
+function bytesN32ScVal(value) {
+  if (value.length !== 32) {
+    throw new Error("Expected exactly 32 bytes.");
+  }
+  return stellarSdk.xdr.ScVal.scvBytes(value);
+}
+function buildAndPrepareTransaction(server, net, sourceAccount, contract, functionName, args, auth) {
+  const builder = new stellarSdk.TransactionBuilder(sourceAccount, {
+    fee: stellarSdk.BASE_FEE,
+    networkPassphrase: net.networkPassphrase
+  }).addOperation(stellarSdk.Operation.invokeContractFunction({ contract, function: functionName, args, auth })).setTimeout(120).build();
+  return server.prepareTransaction(builder);
+}
+async function prepareSmartAccountCall(opts, functionName, args) {
+  const server = new stellarSdk.rpc.Server(opts.net.rpcUrl);
+  const latestLedger = await server.getLatestLedger();
+  const signatureExpirationLedger = latestLedger.sequence + DEFAULT_EXPIRATION_WINDOW_LEDGERS;
+  const rootInvocation = buildInvocation({
+    contractId: opts.net.contracts.smartAccount,
+    functionName,
+    args
+  });
+  const [[entryA, entryB], sourceAccount] = await Promise.all([
+    buildSmartAccountAuthEntries({
+      smartAccountId: opts.net.contracts.smartAccount,
+      rootInvocation,
+      signerAddress: opts.signerAddress,
+      sign: opts.sign,
+      networkPassphrase: opts.net.networkPassphrase,
+      contextRuleIds: opts.contextRuleIds,
+      signatureExpirationLedger
+    }),
+    server.getAccount(opts.feeSourceAddress)
+  ]);
+  return buildAndPrepareTransaction(
+    server,
+    opts.net,
+    sourceAccount,
+    opts.net.contracts.smartAccount,
+    functionName,
+    args,
+    [entryA, entryB]
+  );
+}
+async function prepareTransferPayment(opts, payment) {
+  const args = [
+    addressScVal(payment.asset),
+    addressScVal(payment.destination),
+    i128ScVal(payment.amount),
+    u64ScVal(payment.nonce),
+    u32ScVal(payment.expectedPolicyVersion)
+  ];
+  return prepareSmartAccountCall(opts, "execute_transfer_payment", args);
+}
+async function prepareSplitPayment(opts, payment) {
+  const args = [
+    addressScVal(payment.asset),
+    stellarSdk.xdr.ScVal.scvVec(payment.recipients.map(addressScVal)),
+    stellarSdk.xdr.ScVal.scvVec(payment.amounts.map(i128ScVal)),
+    u64ScVal(payment.nonce),
+    u32ScVal(payment.expectedPolicyVersion)
+  ];
+  return prepareSmartAccountCall(opts, "execute_split_payment", args);
+}
+function scheduledIntentScVal(intent) {
+  return structScVal({
+    intent_id: bytesN32ScVal(intent.intent_id),
+    asset: addressScVal(intent.asset),
+    destination: addressScVal(intent.destination),
+    amount: i128ScVal(intent.amount),
+    start_ledger: u32ScVal(intent.start_ledger),
+    end_ledger: u32ScVal(intent.end_ledger),
+    interval_ledgers: u32ScVal(intent.interval_ledgers),
+    max_executions: u32ScVal(intent.max_executions),
+    execution_count: u32ScVal(intent.execution_count),
+    policy_version: u32ScVal(intent.policy_version),
+    adapter: addressScVal(intent.adapter),
+    cancelled: boolScVal(intent.cancelled)
+  });
+}
+async function prepareScheduledPayment(opts, intent) {
+  const args = [scheduledIntentScVal(intent)];
+  return prepareSmartAccountCall(opts, "create_scheduled_payment", args);
+}
+async function prepareCancelScheduledPayment(opts, intentId) {
+  const args = [bytesN32ScVal(intentId)];
+  return prepareSmartAccountCall(opts, "cancel_scheduled_payment", args);
+}
+async function signAndSubmit(net, tx, feeSourceKeypair) {
+  const server = new stellarSdk.rpc.Server(net.rpcUrl);
+  tx.sign(feeSourceKeypair);
+  const sendResponse = await server.sendTransaction(tx);
+  if (sendResponse.status === "ERROR") {
+    throw new Error(`sendTransaction failed: ${JSON.stringify(sendResponse.errorResult)}`);
+  }
+  let response = await server.getTransaction(sendResponse.hash);
+  for (let attempt = 0; response.status === stellarSdk.rpc.Api.GetTransactionStatus.NOT_FOUND && attempt < MAX_POLL_ATTEMPTS; attempt++) {
+    await new Promise((resolve) => setTimeout(resolve, POLL_INTERVAL_MS));
+    response = await server.getTransaction(sendResponse.hash);
+  }
+  if (response.status === stellarSdk.rpc.Api.GetTransactionStatus.NOT_FOUND) {
+    throw new Error(
+      `transaction ${sendResponse.hash} not found after ${MAX_POLL_ATTEMPTS} polling attempts`
+    );
+  }
+  if (response.status !== stellarSdk.rpc.Api.GetTransactionStatus.SUCCESS) {
+    throw new Error(`transaction ${sendResponse.hash} failed: ${JSON.stringify(response)}`);
+  }
+  return response;
+}
+async function prepareRelayerExecution(opts) {
+  const server = new stellarSdk.rpc.Server(opts.net.rpcUrl);
+  const latestLedger = await server.getLatestLedger();
+  const signatureExpirationLedger = latestLedger.sequence + DEFAULT_EXPIRATION_WINDOW_LEDGERS;
+  const [executorEntry, sourceAccount] = await Promise.all([
+    buildExecutorAuthEntry({
+      intentRegistryId: opts.net.contracts.intentRegistry,
+      intentId: opts.intentId,
+      childSequence: opts.childSequence,
+      executorAddress: opts.executorAddress,
+      sign: opts.sign,
+      networkPassphrase: opts.net.networkPassphrase,
+      signatureExpirationLedger
+    }),
+    server.getAccount(opts.executorAddress)
+  ]);
+  const args = [bytesN32ScVal(opts.intentId), u32ScVal(opts.childSequence)];
+  return buildAndPrepareTransaction(
+    server,
+    opts.net,
+    sourceAccount,
+    opts.net.contracts.smartAccount,
+    "execute_scheduled_payment",
+    args,
+    [executorEntry]
+  );
+}
+function topicSymbol(event) {
+  const body = event.body().v0();
+  const first = body.topics()[0];
+  return first?.switch().name === "scvSymbol" ? first.sym().toString() : void 0;
+}
+var TOPIC_FIELDS = {
+  pay_ok: ["asset", "destination"],
+  splt_ok: ["asset"],
+  auto_ok: ["intent_id"],
+  pol_ok: ["operation"],
+  intent: ["intent_id"],
+  cancel: ["intent_id"],
+  exec: ["intent_id"],
+  open: ["request_id"],
+  appr: ["request_id", "guardian"],
+  final: ["request_id"],
+  recover: ["request_id"],
+  gfreeze: ["guardian"],
+  frozen: []
+};
+function decodeFields(event) {
+  const body = event.body().v0();
+  const topics = body.topics();
+  const topic = topicSymbol(event);
+  const topicFieldNames = topic && topic in TOPIC_FIELDS ? TOPIC_FIELDS[topic] : [];
+  const fromTopics = {};
+  topicFieldNames.forEach((name, i) => {
+    fromTopics[name] = stellarSdk.scValToNative(topics[i + 1]);
+  });
+  const native = stellarSdk.scValToNative(body.data());
+  const fromData = native && typeof native === "object" ? native : {};
+  return { ...fromTopics, ...fromData };
+}
+function parseContractEvent(event) {
+  const topic = topicSymbol(event);
+  const fields = decodeFields(event);
+  return { topic: topic ?? "", event: fields };
+}
+function parseContractEvents(events) {
+  return events.map(parseContractEvent);
+}
+function findEvent(events, topic) {
+  const found = events.find((e) => e.topic === topic);
+  return found?.event;
+}
+function isSimulationError(simulation) {
+  return "error" in simulation;
+}
+async function simulateRead(net, sourceAddress, contractId, method, args = []) {
+  const server = new stellarSdk.rpc.Server(net.rpcUrl);
+  const source = await server.getAccount(sourceAddress);
+  const tx = new stellarSdk.TransactionBuilder(source, { fee: stellarSdk.BASE_FEE, networkPassphrase: net.networkPassphrase }).addOperation(new stellarSdk.Contract(contractId).call(method, ...args)).setTimeout(60).build();
+  const simulation = await server.simulateTransaction(tx);
+  if (isSimulationError(simulation)) {
+    throw new Error(simulation.error);
+  }
+  return simulation.result?.retval ? stellarSdk.scValToNative(simulation.result.retval) : null;
+}
+function u32ScVal2(value) {
+  return stellarSdk.nativeToScVal(value, { type: "u32" });
+}
+function u64ScVal2(value) {
+  return stellarSdk.nativeToScVal(value, { type: "u64" });
+}
+function bytesN32ScVal2(value) {
+  if (value.length !== 32) {
+    throw new Error("Expected exactly 32 bytes.");
+  }
+  return stellarSdk.xdr.ScVal.scvBytes(value);
+}
+function addressScVal2(value) {
+  return stellarSdk.nativeToScVal(value, { type: "address" });
+}
+async function readAccountStatus(net, sourceAddress) {
+  return await simulateRead(net, sourceAddress, net.contracts.smartAccount, "status");
+}
+async function readOwner(net, sourceAddress) {
+  const result = await simulateRead(net, sourceAddress, net.contracts.smartAccount, "get_owner");
+  return typeof result === "string" ? result : null;
+}
+async function readContextRulesCount(net, sourceAddress) {
+  const result = await simulateRead(net, sourceAddress, net.contracts.smartAccount, "get_context_rules_count");
+  return Number(result ?? 0);
+}
+async function readContextRule(net, sourceAddress, contextRuleId) {
+  return await simulateRead(net, sourceAddress, net.contracts.smartAccount, "get_context_rule", [
+    u32ScVal2(contextRuleId)
+  ]);
+}
+async function isNonceUsed(net, sourceAddress, nonce) {
+  const result = await simulateRead(net, sourceAddress, net.contracts.smartAccount, "is_nonce_used", [
+    u64ScVal2(nonce)
+  ]);
+  return Boolean(result);
+}
+async function readPolicyVersion(net, sourceAddress) {
+  const result = await simulateRead(net, sourceAddress, net.contracts.policyEngine, "version");
+  return Number(result ?? 1);
+}
+async function readScheduledIntent(net, sourceAddress, intentId) {
+  return await simulateRead(net, sourceAddress, net.contracts.intentRegistry, "get_intent", [
+    bytesN32ScVal2(intentId)
+  ]);
+}
+async function isChildExecuted(net, sourceAddress, intentId, childSequence) {
+  const result = await simulateRead(net, sourceAddress, net.contracts.intentRegistry, "is_child_executed", [
+    bytesN32ScVal2(intentId),
+    u32ScVal2(childSequence)
+  ]);
+  return Boolean(result);
+}
+async function readRecoveryRequest(net, sourceAddress, requestId) {
+  return await simulateRead(net, sourceAddress, net.contracts.recoveryManager, "request_status", [
+    bytesN32ScVal2(requestId)
+  ]);
+}
+async function readLiveApprovalCount(net, sourceAddress, requestId) {
+  const result = await simulateRead(net, sourceAddress, net.contracts.recoveryManager, "live_approval_count", [
+    bytesN32ScVal2(requestId)
+  ]);
+  return Number(result ?? 0);
+}
+async function isGuardian(net, sourceAddress, guardian) {
+  const result = await simulateRead(net, sourceAddress, net.contracts.recoveryManager, "is_guardian", [
+    addressScVal2(guardian)
+  ]);
+  return Boolean(result);
+}
+async function readGuardianFreezeEpoch(net, sourceAddress) {
+  const result = await simulateRead(net, sourceAddress, net.contracts.recoveryManager, "guardian_freeze_epoch");
+  return Number(result ?? 0);
+}
+async function readFactoryWasmHashes(net, sourceAddress) {
+  return await simulateRead(
+    net,
+    sourceAddress,
+    net.contracts.accountFactory,
+    "get_wasm_hashes"
+  );
+}
+
+Object.defineProperty(exports, "Account", {
+  enumerable: true,
+  get: function () { return stellarSdk.Account; }
+});
+exports.MAINNET = MAINNET;
+exports.MAINNET_NETWORK_PASSPHRASE = MAINNET_NETWORK_PASSPHRASE;
+exports.MAINNET_RPC_URL_ENV = MAINNET_RPC_URL_ENV;
+exports.NETWORKS = NETWORKS;
+exports.TESTNET = TESTNET;
+exports.buildExecutorAuthEntry = buildExecutorAuthEntry;
+exports.buildInvocation = buildInvocation;
+exports.buildMainnetConfig = buildMainnetConfig;
+exports.buildSmartAccountAuthEntries = buildSmartAccountAuthEntries;
+exports.findEvent = findEvent;
+exports.isChildExecuted = isChildExecuted;
+exports.isGuardian = isGuardian;
+exports.isNonceUsed = isNonceUsed;
+exports.parseContractEvent = parseContractEvent;
+exports.parseContractEvents = parseContractEvents;
+exports.prepareCancelScheduledPayment = prepareCancelScheduledPayment;
+exports.prepareRelayerExecution = prepareRelayerExecution;
+exports.prepareScheduledPayment = prepareScheduledPayment;
+exports.prepareSplitPayment = prepareSplitPayment;
+exports.prepareTransferPayment = prepareTransferPayment;
+exports.readAccountStatus = readAccountStatus;
+exports.readContextRule = readContextRule;
+exports.readContextRulesCount = readContextRulesCount;
+exports.readFactoryWasmHashes = readFactoryWasmHashes;
+exports.readGuardianFreezeEpoch = readGuardianFreezeEpoch;
+exports.readLiveApprovalCount = readLiveApprovalCount;
+exports.readOwner = readOwner;
+exports.readPolicyVersion = readPolicyVersion;
+exports.readRecoveryRequest = readRecoveryRequest;
+exports.readScheduledIntent = readScheduledIntent;
+exports.signAndSubmit = signAndSubmit;
+exports.signaturePayload = signaturePayload;
+//# sourceMappingURL=index.cjs.map
+//# sourceMappingURL=index.cjs.map