@akta/sdk 1.3.26 → 1.3.28

package/dist/wallet/index.mjs

@@ -38,9 +38,9 @@ import {
   newWallet,
   parseWalletErrorCode,
   translateWalletError
-} from "../chunk-S4OJ4Y5G.mjs";
+} from "../chunk-KWFYX34V.mjs";
 import "../chunk-2ZPJXFUS.mjs";
-import "../chunk-5F555WJV.mjs";
+import "../chunk-JIDDRUHU.mjs";
 import "../chunk-2EQ6E26U.mjs";
 import "../chunk-XLWSHPHP.mjs";
 import "../chunk-RFJII2P3.mjs";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@akta/sdk",
-  "version": "1.3.26",
+  "version": "1.3.28",
   "main": "dist/index.js",
   "module": "dist/index.mjs",
   "types": "dist/index.d.ts",

package/dist/chunk-5F555WJV.mjs.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../src/utils.ts"],"sourcesContent":["import algosdk from \"algosdk\";\nimport { randomBytes as nobleRandomBytes } from \"@noble/hashes/utils\";\nimport {\n  ABIStructType,\n  ABIType,\n  ABIValue,\n  StructField,\n  getABIDecodedValue as getABIDecodedValueRaw,\n  getABIEncodedValue as getABIEncodedValueRaw,\n  getTupleValueFromStructValue,\n} from \"@algorandfoundation/algokit-utils/abi\";\nimport { decodeTransaction } from \"@algorandfoundation/algokit-utils/transact\";\n\n/**\n * Local alias for the struct-shaped ABIValue. The upstream\n * @algorandfoundation/algokit-utils/abi module defines this type in\n * abi-value.d.ts but doesn't re-export it from the public /abi index,\n * so we mirror it here to preserve the ergonomic name.\n */\nexport type ABIStructValue = {\n  [key: string]: ABIValue;\n};\n\nexport function convertToUnixTimestamp(timestamp: bigint): bigint {\n  return timestamp * 1_000n;\n}\n\nexport function convertFromUnixTimestamp(timestamp: bigint): bigint {\n  return timestamp / 1_000n;\n}\n\nexport function assertByteArrayLength(value: Uint8Array, name: string, length: number): void {\n  if (!(value instanceof Uint8Array) || value.length !== length) {\n    throw new Error(`${name} must be ${length} bytes`);\n  }\n}\n\nexport function randomByteArray(length: number): Uint8Array {\n  return nobleRandomBytes(length);\n}\n\n/**\n * Reorders a struct-shaped value so its keys are in the exact order declared by the\n * struct definition, and drops any keys that aren't part of the struct. Also recurses\n * into nested struct-typed fields.\n *\n * This is required because algokit-utils' `getTupleValueFromStructValue` internally\n * calls `Object.values(structValue)` and maps positionally against the struct's\n * `structFields` — it does NOT look up by name. Any extra field or misordered field\n * in the source object shifts the tuple and produces wildly wrong encodings (e.g.\n * \"Cannot encode value as byte[32]:\" when an empty `escrow` string lands where\n * `executionKey` was expected because an extra `caller` field shifted everything).\n */\nfunction reorderStructValue(\n  value: ABIStructValue,\n  fields: StructField[],\n  structs: Record<string, StructField[]>,\n): ABIStructValue {\n  const ordered: ABIStructValue = {};\n  for (const field of fields) {\n    const fieldValue = value[field.name];\n    // Recurse into nested struct-typed fields referenced by struct name\n    if (\n      typeof field.type === 'string' &&\n      field.type in structs &&\n      fieldValue !== undefined &&\n      fieldValue !== null &&\n      typeof fieldValue === 'object' &&\n      !Array.isArray(fieldValue) &&\n      !(fieldValue instanceof Uint8Array)\n    ) {\n      ordered[field.name] = reorderStructValue(\n        fieldValue as ABIStructValue,\n        structs[field.type],\n        structs,\n      );\n    } else {\n      ordered[field.name] = fieldValue;\n    }\n  }\n  return ordered;\n}\n\n/**\n * The utils10 `getABIEncodedValue`/`getABIDecodedValue` accept either:\n *   - one of the special \"AVM type\" string literals (\"AVMString\", \"AVMBytes\", \"AVMUint64\")\n *   - or an `ABIType` instance (NOT an ARC-4 type string)\n *\n * The legacy v9 API let you pass ARC-4 type strings like \"uint64\" or\n * \"((uint64,string),uint8,uint64)[]\" directly. Our compat wrappers preserve that\n * convenience by parsing the string into an `ABIType` via `ABIType.from(typeName)`\n * when it isn't a struct name and isn't an AVM type.\n */\nconst AVM_TYPE_NAMES = new Set([\"AVMString\", \"AVMBytes\", \"AVMUint64\"]);\n\n/**\n * Compatibility wrapper for the old `getABIEncodedValue(value, typeName, structs)` signature\n * from algokit-utils v9. Internally constructs an ABIStructType or ABIType and delegates\n * to the v10 `getABIEncodedValue(type, value)` API.\n */\nexport function encodeABIValue(\n  value: ABIValue | ABIStructValue,\n  typeName: string,\n  structs: Record<string, StructField[]>,\n): Uint8Array {\n  // If the caller passed a struct name, build the struct type and convert the value\n  if (typeName in structs) {\n    const structType = ABIStructType.fromStruct(typeName, structs);\n    // Reorder to match struct field order and drop extra properties — utils10 maps\n    // by position, not name, so source-object key order matters here.\n    const orderedValue = reorderStructValue(\n      value as ABIStructValue,\n      structs[typeName],\n      structs,\n    );\n    const tupleValue = getTupleValueFromStructValue(structType, orderedValue);\n    return getABIEncodedValueRaw(structType, tupleValue);\n  }\n  // AVM type literals pass through unchanged\n  if (AVM_TYPE_NAMES.has(typeName)) {\n    return getABIEncodedValueRaw(typeName as never, value as ABIValue);\n  }\n  // Otherwise treat the typeName as an ARC-4 type descriptor and build an ABIType from it\n  const abiType = ABIType.from(typeName);\n  return getABIEncodedValueRaw(abiType, value as ABIValue);\n}\n\n/**\n * Compatibility wrapper for the old `getABIDecodedValue(bytes, typeName, structs)` signature.\n * Returns the struct value form when decoding into a named struct.\n */\nexport function decodeABIValue(\n  bytes: Uint8Array,\n  typeName: string,\n  structs: Record<string, StructField[]>,\n): ABIValue | ABIStructValue {\n  if (typeName in structs) {\n    // v10 ABIStructType.decode() already returns a struct value (object with named\n    // fields), not a tuple — so pass the result through directly. (v9 returned a\n    // tuple here, which is why this used to call getStructValueFromTupleValue.)\n    const structType = ABIStructType.fromStruct(typeName, structs);\n    return getABIDecodedValueRaw(structType, bytes) as ABIStructValue;\n  }\n  if (AVM_TYPE_NAMES.has(typeName)) {\n    return getABIDecodedValueRaw(typeName as never, bytes);\n  }\n  const abiType = ABIType.from(typeName);\n  return getABIDecodedValueRaw(abiType, bytes);\n}\n\n/**\n * Bridge between utils10 and algosdk signer conventions.\n *\n * `sendPrepared` invokes signers with `algosdk.Transaction` objects (we\n * deliberately hold transactions in algosdk shape after `prepareGroup` so\n * their fields — sender, lease, fee, validity — remain mutable for the arc58\n * execution-handoff path). A utils10 signer, however, expects the\n * `utils10.Transaction` shape (which uses `appCall`/`payment`/etc. fields\n * instead of algosdk's flat layout); passing algosdk objects through a\n * utils10 signer produces signed bytes with empty app-call fields.\n *\n * This wrapper re-encodes each algosdk transaction to canonical msgpack bytes\n * and decodes them back into utils10 `Transaction` objects before handing\n * them to the utils10 signer.\n *\n * Tolerant of inputs that are ALREADY utils10 Transactions: passes them\n * through unchanged. That case arises when the same signer is attached to\n * both a `sendPrepared` call (algosdk inputs) and a direct utils10 composer\n * send (utils10 inputs). Without this detection,\n * `algosdk.encodeUnsignedTransaction` would throw\n * `e.getEncodingSchema is not a function`.\n */\nexport function wrapUtils10Signer(utils10Signer: unknown): algosdk.TransactionSigner {\n  return async (txnGroup: algosdk.Transaction[], indexesToSign: number[]) => {\n    const utils10Group = txnGroup.map((t) => {\n      // algosdk.Transaction implements `getEncodingSchema()` as part of its Encodable\n      // interface. utils10.Transaction has no such method — it encodes/decodes via\n      // the standalone `encodeTransactionRaw` / `decodeTransaction` helpers. Use this\n      // as a duck-typed discriminator; only re-encode when the input is algosdk.\n      if (typeof (t as { getEncodingSchema?: unknown }).getEncodingSchema === 'function') {\n        const bytes = algosdk.encodeUnsignedTransaction(t);\n        return decodeTransaction(bytes);\n      }\n      return t;\n    });\n    return (utils10Signer as (g: unknown[], i: number[]) => Promise<Uint8Array[]>)(\n      utils10Group,\n      indexesToSign,\n    );\n  };\n}\n"],"mappings":";AAAA,OAAO,aAAa;AACpB,SAAS,eAAe,wBAAwB;AAChD;AAAA,EACE;AAAA,EACA;AAAA,EAGA,sBAAsB;AAAA,EACtB,sBAAsB;AAAA,EACtB;AAAA,OACK;AACP,SAAS,yBAAyB;AAY3B,SAAS,uBAAuB,WAA2B;AAChE,SAAO,YAAY;AACrB;AAMO,SAAS,sBAAsB,OAAmB,MAAc,QAAsB;AAC3F,MAAI,EAAE,iBAAiB,eAAe,MAAM,WAAW,QAAQ;AAC7D,UAAM,IAAI,MAAM,GAAG,IAAI,YAAY,MAAM,QAAQ;AAAA,EACnD;AACF;AAEO,SAAS,gBAAgB,QAA4B;AAC1D,SAAO,iBAAiB,MAAM;AAChC;AAcA,SAAS,mBACP,OACA,QACA,SACgB;AAChB,QAAM,UAA0B,CAAC;AACjC,aAAW,SAAS,QAAQ;AAC1B,UAAM,aAAa,MAAM,MAAM,IAAI;AAEnC,QACE,OAAO,MAAM,SAAS,YACtB,MAAM,QAAQ,WACd,eAAe,UACf,eAAe,QACf,OAAO,eAAe,YACtB,CAAC,MAAM,QAAQ,UAAU,KACzB,EAAE,sBAAsB,aACxB;AACA,cAAQ,MAAM,IAAI,IAAI;AAAA,QACpB;AAAA,QACA,QAAQ,MAAM,IAAI;AAAA,QAClB;AAAA,MACF;AAAA,IACF,OAAO;AACL,cAAQ,MAAM,IAAI,IAAI;AAAA,IACxB;AAAA,EACF;AACA,SAAO;AACT;AAYA,IAAM,iBAAiB,oBAAI,IAAI,CAAC,aAAa,YAAY,WAAW,CAAC;AAO9D,SAAS,eACd,OACA,UACA,SACY;AAEZ,MAAI,YAAY,SAAS;AACvB,UAAM,aAAa,cAAc,WAAW,UAAU,OAAO;AAG7D,UAAM,eAAe;AAAA,MACnB;AAAA,MACA,QAAQ,QAAQ;AAAA,MAChB;AAAA,IACF;AACA,UAAM,aAAa,6BAA6B,YAAY,YAAY;AACxE,WAAO,sBAAsB,YAAY,UAAU;AAAA,EACrD;AAEA,MAAI,eAAe,IAAI,QAAQ,GAAG;AAChC,WAAO,sBAAsB,UAAmB,KAAiB;AAAA,EACnE;AAEA,QAAM,UAAU,QAAQ,KAAK,QAAQ;AACrC,SAAO,sBAAsB,SAAS,KAAiB;AACzD;AAMO,SAAS,eACd,OACA,UACA,SAC2B;AAC3B,MAAI,YAAY,SAAS;AAIvB,UAAM,aAAa,cAAc,WAAW,UAAU,OAAO;AAC7D,WAAO,sBAAsB,YAAY,KAAK;AAAA,EAChD;AACA,MAAI,eAAe,IAAI,QAAQ,GAAG;AAChC,WAAO,sBAAsB,UAAmB,KAAK;AAAA,EACvD;AACA,QAAM,UAAU,QAAQ,KAAK,QAAQ;AACrC,SAAO,sBAAsB,SAAS,KAAK;AAC7C;AAwBO,SAAS,kBAAkB,eAAmD;AACnF,SAAO,OAAO,UAAiC,kBAA4B;AACzE,UAAM,eAAe,SAAS,IAAI,CAAC,MAAM;AAKvC,UAAI,OAAQ,EAAsC,sBAAsB,YAAY;AAClF,cAAM,QAAQ,QAAQ,0BAA0B,CAAC;AACjD,eAAO,kBAAkB,KAAK;AAAA,MAChC;AACA,aAAO;AAAA,IACT,CAAC;AACD,WAAQ;AAAA,MACN;AAAA,MACA;AAAA,IACF;AAAA,EACF;AACF;","names":[]}

package/dist/chunk-AW5G7J3L.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":["/Users/kylebreeding/akita/akita-sc/projects/akita-sdk/dist/chunk-AW5G7J3L.js","../src/utils.ts"],"names":[],"mappings":"AAAA;ACAA,oFAAoB;AACpB,4CAAgD;AAChD;AACE;AACA;AAGA;AACA;AACA;AAAA,4DACK;AACP,sEAAkC;AAY3B,SAAS,sBAAA,CAAuB,SAAA,EAA2B;AAChE,EAAA,OAAO,UAAA,EAAY,KAAA;AACrB;AAMO,SAAS,qBAAA,CAAsB,KAAA,EAAmB,IAAA,EAAc,MAAA,EAAsB;AAC3F,EAAA,GAAA,CAAI,CAAA,CAAE,MAAA,WAAiB,UAAA,EAAA,GAAe,KAAA,CAAM,OAAA,IAAW,MAAA,EAAQ;AAC7D,IAAA,MAAM,IAAI,KAAA,CAAM,CAAA,EAAA;AAClB,EAAA;AACF;AAEgB;AACP,EAAA;AACT;AAcS;AAK0B,EAAA;AACtB,EAAA;AACH,IAAA;AAGS,IAAA;AAQC,MAAA;AACZ,QAAA;AACQ,QAAA;AACR,QAAA;AACF,MAAA;AACK,IAAA;AACS,MAAA;AAChB,IAAA;AACF,EAAA;AACO,EAAA;AACT;AAYuB;AAOP;AAME,EAAA;AACR,IAAA;AAGA,IAAA;AACJ,MAAA;AACQ,MAAA;AACR,MAAA;AACF,IAAA;AACM,IAAA;AACC,IAAA;AACT,EAAA;AAEmB,EAAA;AACV,IAAA;AACT,EAAA;AAEgB,EAAA;AACT,EAAA;AACT;AAMgB;AAKE,EAAA;AAIR,IAAA;AACC,IAAA;AACT,EAAA;AACmB,EAAA;AACV,IAAA;AACT,EAAA;AACgB,EAAA;AACT,EAAA;AACT;AAwBgB;AACA,EAAA;AACN,IAAA;AAK8C,MAAA;AAC1C,QAAA;AACC,QAAA;AACT,MAAA;AACO,MAAA;AACR,IAAA;AACO,IAAA;AACN,MAAA;AACA,MAAA;AACF,IAAA;AACF,EAAA;AACF;AD5GqB;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA","file":"/Users/kylebreeding/akita/akita-sc/projects/akita-sdk/dist/chunk-AW5G7J3L.js","sourcesContent":[null,"import algosdk from \"algosdk\";\nimport { randomBytes as nobleRandomBytes } from \"@noble/hashes/utils\";\nimport {\n  ABIStructType,\n  ABIType,\n  ABIValue,\n  StructField,\n  getABIDecodedValue as getABIDecodedValueRaw,\n  getABIEncodedValue as getABIEncodedValueRaw,\n  getTupleValueFromStructValue,\n} from \"@algorandfoundation/algokit-utils/abi\";\nimport { decodeTransaction } from \"@algorandfoundation/algokit-utils/transact\";\n\n/**\n * Local alias for the struct-shaped ABIValue. The upstream\n * @algorandfoundation/algokit-utils/abi module defines this type in\n * abi-value.d.ts but doesn't re-export it from the public /abi index,\n * so we mirror it here to preserve the ergonomic name.\n */\nexport type ABIStructValue = {\n  [key: string]: ABIValue;\n};\n\nexport function convertToUnixTimestamp(timestamp: bigint): bigint {\n  return timestamp * 1_000n;\n}\n\nexport function convertFromUnixTimestamp(timestamp: bigint): bigint {\n  return timestamp / 1_000n;\n}\n\nexport function assertByteArrayLength(value: Uint8Array, name: string, length: number): void {\n  if (!(value instanceof Uint8Array) || value.length !== length) {\n    throw new Error(`${name} must be ${length} bytes`);\n  }\n}\n\nexport function randomByteArray(length: number): Uint8Array {\n  return nobleRandomBytes(length);\n}\n\n/**\n * Reorders a struct-shaped value so its keys are in the exact order declared by the\n * struct definition, and drops any keys that aren't part of the struct. Also recurses\n * into nested struct-typed fields.\n *\n * This is required because algokit-utils' `getTupleValueFromStructValue` internally\n * calls `Object.values(structValue)` and maps positionally against the struct's\n * `structFields` — it does NOT look up by name. Any extra field or misordered field\n * in the source object shifts the tuple and produces wildly wrong encodings (e.g.\n * \"Cannot encode value as byte[32]:\" when an empty `escrow` string lands where\n * `executionKey` was expected because an extra `caller` field shifted everything).\n */\nfunction reorderStructValue(\n  value: ABIStructValue,\n  fields: StructField[],\n  structs: Record<string, StructField[]>,\n): ABIStructValue {\n  const ordered: ABIStructValue = {};\n  for (const field of fields) {\n    const fieldValue = value[field.name];\n    // Recurse into nested struct-typed fields referenced by struct name\n    if (\n      typeof field.type === 'string' &&\n      field.type in structs &&\n      fieldValue !== undefined &&\n      fieldValue !== null &&\n      typeof fieldValue === 'object' &&\n      !Array.isArray(fieldValue) &&\n      !(fieldValue instanceof Uint8Array)\n    ) {\n      ordered[field.name] = reorderStructValue(\n        fieldValue as ABIStructValue,\n        structs[field.type],\n        structs,\n      );\n    } else {\n      ordered[field.name] = fieldValue;\n    }\n  }\n  return ordered;\n}\n\n/**\n * The utils10 `getABIEncodedValue`/`getABIDecodedValue` accept either:\n *   - one of the special \"AVM type\" string literals (\"AVMString\", \"AVMBytes\", \"AVMUint64\")\n *   - or an `ABIType` instance (NOT an ARC-4 type string)\n *\n * The legacy v9 API let you pass ARC-4 type strings like \"uint64\" or\n * \"((uint64,string),uint8,uint64)[]\" directly. Our compat wrappers preserve that\n * convenience by parsing the string into an `ABIType` via `ABIType.from(typeName)`\n * when it isn't a struct name and isn't an AVM type.\n */\nconst AVM_TYPE_NAMES = new Set([\"AVMString\", \"AVMBytes\", \"AVMUint64\"]);\n\n/**\n * Compatibility wrapper for the old `getABIEncodedValue(value, typeName, structs)` signature\n * from algokit-utils v9. Internally constructs an ABIStructType or ABIType and delegates\n * to the v10 `getABIEncodedValue(type, value)` API.\n */\nexport function encodeABIValue(\n  value: ABIValue | ABIStructValue,\n  typeName: string,\n  structs: Record<string, StructField[]>,\n): Uint8Array {\n  // If the caller passed a struct name, build the struct type and convert the value\n  if (typeName in structs) {\n    const structType = ABIStructType.fromStruct(typeName, structs);\n    // Reorder to match struct field order and drop extra properties — utils10 maps\n    // by position, not name, so source-object key order matters here.\n    const orderedValue = reorderStructValue(\n      value as ABIStructValue,\n      structs[typeName],\n      structs,\n    );\n    const tupleValue = getTupleValueFromStructValue(structType, orderedValue);\n    return getABIEncodedValueRaw(structType, tupleValue);\n  }\n  // AVM type literals pass through unchanged\n  if (AVM_TYPE_NAMES.has(typeName)) {\n    return getABIEncodedValueRaw(typeName as never, value as ABIValue);\n  }\n  // Otherwise treat the typeName as an ARC-4 type descriptor and build an ABIType from it\n  const abiType = ABIType.from(typeName);\n  return getABIEncodedValueRaw(abiType, value as ABIValue);\n}\n\n/**\n * Compatibility wrapper for the old `getABIDecodedValue(bytes, typeName, structs)` signature.\n * Returns the struct value form when decoding into a named struct.\n */\nexport function decodeABIValue(\n  bytes: Uint8Array,\n  typeName: string,\n  structs: Record<string, StructField[]>,\n): ABIValue | ABIStructValue {\n  if (typeName in structs) {\n    // v10 ABIStructType.decode() already returns a struct value (object with named\n    // fields), not a tuple — so pass the result through directly. (v9 returned a\n    // tuple here, which is why this used to call getStructValueFromTupleValue.)\n    const structType = ABIStructType.fromStruct(typeName, structs);\n    return getABIDecodedValueRaw(structType, bytes) as ABIStructValue;\n  }\n  if (AVM_TYPE_NAMES.has(typeName)) {\n    return getABIDecodedValueRaw(typeName as never, bytes);\n  }\n  const abiType = ABIType.from(typeName);\n  return getABIDecodedValueRaw(abiType, bytes);\n}\n\n/**\n * Bridge between utils10 and algosdk signer conventions.\n *\n * `sendPrepared` invokes signers with `algosdk.Transaction` objects (we\n * deliberately hold transactions in algosdk shape after `prepareGroup` so\n * their fields — sender, lease, fee, validity — remain mutable for the arc58\n * execution-handoff path). A utils10 signer, however, expects the\n * `utils10.Transaction` shape (which uses `appCall`/`payment`/etc. fields\n * instead of algosdk's flat layout); passing algosdk objects through a\n * utils10 signer produces signed bytes with empty app-call fields.\n *\n * This wrapper re-encodes each algosdk transaction to canonical msgpack bytes\n * and decodes them back into utils10 `Transaction` objects before handing\n * them to the utils10 signer.\n *\n * Tolerant of inputs that are ALREADY utils10 Transactions: passes them\n * through unchanged. That case arises when the same signer is attached to\n * both a `sendPrepared` call (algosdk inputs) and a direct utils10 composer\n * send (utils10 inputs). Without this detection,\n * `algosdk.encodeUnsignedTransaction` would throw\n * `e.getEncodingSchema is not a function`.\n */\nexport function wrapUtils10Signer(utils10Signer: unknown): algosdk.TransactionSigner {\n  return async (txnGroup: algosdk.Transaction[], indexesToSign: number[]) => {\n    const utils10Group = txnGroup.map((t) => {\n      // algosdk.Transaction implements `getEncodingSchema()` as part of its Encodable\n      // interface. utils10.Transaction has no such method — it encodes/decodes via\n      // the standalone `encodeTransactionRaw` / `decodeTransaction` helpers. Use this\n      // as a duck-typed discriminator; only re-encode when the input is algosdk.\n      if (typeof (t as { getEncodingSchema?: unknown }).getEncodingSchema === 'function') {\n        const bytes = algosdk.encodeUnsignedTransaction(t);\n        return decodeTransaction(bytes);\n      }\n      return t;\n    });\n    return (utils10Signer as (g: unknown[], i: number[]) => Promise<Uint8Array[]>)(\n      utils10Group,\n      indexesToSign,\n    );\n  };\n}\n"]}