@arxiumlabs/sdk 0.4.0 → 0.5.0

package/README.md

@@ -123,3 +123,17 @@ stateful witnesses; `arx verify SIGNATURE --policy FILE` accepts that policy.
 
 See [the programmable-account guide](../../docs/Programmable_Accounts.md) for
 configuration shapes, fees, block-height windows, recovery and reset requirements.
+
+## Release validation
+
+CI builds and installs the packed SDK on pull requests. Run `npm ci`,
+`npm run test:release`, `npm test`, then `npm run check:package` locally.
+The package check installs the tarball in a temporary directory, imports its
+public entry point and checks the CLI version; it makes no chain calls.
+
+Publication runs only for an approved `sdk-vX.Y.Z` tag matching package.json.
+The publish job builds its own checkout, checks the packed files and smoke-tests
+the tarball, then publishes that exact tarball with provenance. Existing npm
+versions cannot be replaced. npm trusted-publisher configuration and release
+authorization are still required; a passing package check is not publication
+or on-chain compatibility proof.

package/dist/actions.d.ts

@@ -23,7 +23,15 @@ export declare const ACTION_VARIANT: {
     readonly issuerForcedTransfer: 22;
     readonly recoverHolder: 23;
     readonly issueAssetTo: 24;
+    readonly lockIssuance: 25;
+    readonly transferIssuer: 26;
+    readonly setAssetMetadataUri: 27;
     readonly setAssetLimits: 28;
+    readonly lockHolderAmountUntil: 29;
+    readonly snapshotHolders: 33;
+    readonly distributeToHolders: 34;
+    readonly redeemHolders: 35;
+    readonly splitAsset: 36;
     readonly verifyClaimProof: 37;
     readonly setPrivateClaims: 38;
     readonly submitProposal: 30;
@@ -89,6 +97,22 @@ export declare function encodeLockHolderAmount(asset: string, holder: string, am
 export declare function encodeIssuerForcedTransfer(asset: string, from: string, to: string, amount: bigint, reason: string): Uint8Array;
 export declare function encodeRecoverHolder(asset: string, lost: string, replacement: string): Uint8Array;
 export declare function encodeIssueAssetTo(asset: string, to: string, amount: bigint): Uint8Array;
+/** One-way: the issuer gives up minting and `max_supply` is pinned to the current supply. */
+export declare function encodeLockIssuance(asset: string): Uint8Array;
+/** Hands every issuer right over `asset` to `newIssuer` (key rotation, compromise remedy). */
+export declare function encodeTransferIssuer(asset: string, newIssuer: string): Uint8Array;
+/** `null` clears the link. */
+export declare function encodeSetAssetMetadataUri(asset: string, metadataUri: string | null): Uint8Array;
+/** A holding period: the lock releases itself at `untilHeight`. */
+export declare function encodeLockHolderAmountUntil(asset: string, holder: string, amount: bigint, untilHeight: bigint): Uint8Array;
+/** Records the record-date cap table; the corporate actions below name it by its block height. */
+export declare function encodeSnapshotHolders(asset: string): Uint8Array;
+/** Dividend/coupon: pays `total` of `payoutAsset` pro rata to the snapshot at `snapshotHeight`. */
+export declare function encodeDistributeToHolders(asset: string, snapshotHeight: bigint, payoutAsset: string, total: bigint): Uint8Array;
+/** Forces every snapshot balance back to the issuer. Send the proceeds with `encodeDistributeToHolders` first. */
+export declare function encodeRedeemHolders(asset: string, snapshotHeight: bigint): Uint8Array;
+/** Each snapshot holding `b` becomes `b * numerator / denominator` (split if >1, consolidation if <1). */
+export declare function encodeSplitAsset(asset: string, snapshotHeight: bigint, numerator: bigint, denominator: bigint): Uint8Array;
 /** Sets issuer-controlled investor, concentration, and attestation-age limits. `null` clears each limit. */
 /** zk-KYC: a holder's private eligibility proof. `sub` is a fixed 32-byte array on the node, so it rides raw (no length prefix); `proof` is length-prefixed. */
 export declare function encodeVerifyClaimProof(asset: string, sub: Uint8Array, todayDays: number, proof: Uint8Array): Uint8Array;

package/dist/actions.js

@@ -8,7 +8,9 @@ export const ACTION_VARIANT = {
     registerAsset: 12, issueAsset: 13, transferAsset: 14, freezeAsset: 16, unfreezeAsset: 17,
     burnAsset: 18, setHolderFrozen: 19, lockHolderAmount: 20, unlockHolderAmount: 21,
     issuerForcedTransfer: 22, recoverHolder: 23, issueAssetTo: 24,
-    setAssetLimits: 28, verifyClaimProof: 37, setPrivateClaims: 38,
+    lockIssuance: 25, transferIssuer: 26, setAssetMetadataUri: 27, setAssetLimits: 28, lockHolderAmountUntil: 29,
+    snapshotHolders: 33, distributeToHolders: 34, redeemHolders: 35, splitAsset: 36,
+    verifyClaimProof: 37, setPrivateClaims: 38,
     submitProposal: 30, voteProposal: 31, executeProposal: 32,
     applyAttestor: 41, blockAttestor: 42,
 };
@@ -38,6 +40,22 @@ export function encodeLockHolderAmount(asset, holder, amount, lock) { return new
 export function encodeIssuerForcedTransfer(asset, from, to, amount, reason) { return new Writer().varint(ACTION_VARIANT.issuerForcedTransfer).string(asset).string(from).string(to).varint(amount).string(reason).bytes(); }
 export function encodeRecoverHolder(asset, lost, replacement) { return new Writer().varint(ACTION_VARIANT.recoverHolder).string(asset).string(lost).string(replacement).bytes(); }
 export function encodeIssueAssetTo(asset, to, amount) { return new Writer().varint(ACTION_VARIANT.issueAssetTo).string(asset).string(to).varint(amount).bytes(); }
+/** One-way: the issuer gives up minting and `max_supply` is pinned to the current supply. */
+export function encodeLockIssuance(asset) { return new Writer().varint(ACTION_VARIANT.lockIssuance).string(asset).bytes(); }
+/** Hands every issuer right over `asset` to `newIssuer` (key rotation, compromise remedy). */
+export function encodeTransferIssuer(asset, newIssuer) { return new Writer().varint(ACTION_VARIANT.transferIssuer).string(asset).string(newIssuer).bytes(); }
+/** `null` clears the link. */
+export function encodeSetAssetMetadataUri(asset, metadataUri) { return new Writer().varint(ACTION_VARIANT.setAssetMetadataUri).string(asset).option(metadataUri, (w, uri) => w.string(uri)).bytes(); }
+/** A holding period: the lock releases itself at `untilHeight`. */
+export function encodeLockHolderAmountUntil(asset, holder, amount, untilHeight) { return new Writer().varint(ACTION_VARIANT.lockHolderAmountUntil).string(asset).string(holder).varint(amount).varint(untilHeight).bytes(); }
+/** Records the record-date cap table; the corporate actions below name it by its block height. */
+export function encodeSnapshotHolders(asset) { return new Writer().varint(ACTION_VARIANT.snapshotHolders).string(asset).bytes(); }
+/** Dividend/coupon: pays `total` of `payoutAsset` pro rata to the snapshot at `snapshotHeight`. */
+export function encodeDistributeToHolders(asset, snapshotHeight, payoutAsset, total) { return new Writer().varint(ACTION_VARIANT.distributeToHolders).string(asset).varint(snapshotHeight).string(payoutAsset).varint(total).bytes(); }
+/** Forces every snapshot balance back to the issuer. Send the proceeds with `encodeDistributeToHolders` first. */
+export function encodeRedeemHolders(asset, snapshotHeight) { return new Writer().varint(ACTION_VARIANT.redeemHolders).string(asset).varint(snapshotHeight).bytes(); }
+/** Each snapshot holding `b` becomes `b * numerator / denominator` (split if >1, consolidation if <1). */
+export function encodeSplitAsset(asset, snapshotHeight, numerator, denominator) { return new Writer().varint(ACTION_VARIANT.splitAsset).string(asset).varint(snapshotHeight).varint(numerator).varint(denominator).bytes(); }
 /** Sets issuer-controlled investor, concentration, and attestation-age limits. `null` clears each limit. */
 /** zk-KYC: a holder's private eligibility proof. `sub` is a fixed 32-byte array on the node, so it rides raw (no length prefix); `proof` is length-prefixed. */
 export function encodeVerifyClaimProof(asset, sub, todayDays, proof) { if (sub.length !== 32)
@@ -96,6 +114,14 @@ export function encodePayload({ name, input }) {
         case "issuerForcedTransfer": return encodeIssuerForcedTransfer(input.asset, input.from, input.to, BigInt(input.amount), input.reason);
         case "recoverHolder": return encodeRecoverHolder(input.asset, input.lost, input.replacement);
         case "issueAssetTo": return encodeIssueAssetTo(input.asset, input.to, BigInt(input.amount));
+        case "lockIssuance": return encodeLockIssuance(input.asset);
+        case "transferIssuer": return encodeTransferIssuer(input.asset, input.newIssuer);
+        case "setAssetMetadataUri": return encodeSetAssetMetadataUri(input.asset, input.metadataUri);
+        case "lockHolderAmountUntil": return encodeLockHolderAmountUntil(input.asset, input.holder, BigInt(input.amount), BigInt(input.untilHeight));
+        case "snapshotHolders": return encodeSnapshotHolders(input.asset);
+        case "distributeToHolders": return encodeDistributeToHolders(input.asset, BigInt(input.snapshotHeight), input.payoutAsset, BigInt(input.total));
+        case "redeemHolders": return encodeRedeemHolders(input.asset, BigInt(input.snapshotHeight));
+        case "splitAsset": return encodeSplitAsset(input.asset, BigInt(input.snapshotHeight), BigInt(input.numerator), BigInt(input.denominator));
         case "setAssetLimits": return encodeSetAssetLimits(input.asset, input.maxHolders, nullableBig(input.maxBalancePerHolder), nullableBig(input.maxAttestationAge));
         case "verifyClaimProof": return encodeVerifyClaimProof(input.asset, Uint8Array.from(input.sub), input.todayDays, Uint8Array.from(input.proof));
         case "setPrivateClaims": return encodeSetPrivateClaims(input.asset, input.enabled);
@@ -154,6 +180,14 @@ export function decodePayload(payload) {
         issuerForcedTransfer: () => ({ asset: str(), from: str(), to: str(), amount: amount(), reason: str() }),
         recoverHolder: () => ({ asset: str(), lost: str(), replacement: str() }),
         issueAssetTo: () => ({ asset: str(), to: str(), amount: amount() }),
+        lockIssuance: () => ({ asset: str() }),
+        transferIssuer: () => ({ asset: str(), newIssuer: str() }),
+        setAssetMetadataUri: () => ({ asset: str(), metadataUri: r.option(str) }),
+        lockHolderAmountUntil: () => ({ asset: str(), holder: str(), amount: amount(), untilHeight: amount() }),
+        snapshotHolders: () => ({ asset: str() }),
+        distributeToHolders: () => ({ asset: str(), snapshotHeight: amount(), payoutAsset: str(), total: amount() }),
+        redeemHolders: () => ({ asset: str(), snapshotHeight: amount() }),
+        splitAsset: () => ({ asset: str(), snapshotHeight: amount(), numerator: amount(), denominator: amount() }),
         setAssetLimits: () => ({ asset: str(), maxHolders: r.option((rr) => Number(rr.varint())), maxBalancePerHolder: r.option(amount), maxAttestationAge: r.option(amount) }),
         verifyClaimProof: () => ({ asset: str(), sub: Array.from({ length: 32 }, () => r.u8()), todayDays: Number(r.varint()), proof: bytes() }),
         setPrivateClaims: () => ({ asset: str(), enabled: r.bool() }),

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@arxiumlabs/sdk",
-  "version": "0.4.0",
+  "version": "0.5.0",
   "description": "Arxium TypeScript SDK and arx CLI",
   "type": "module",
   "private": false,
@@ -32,6 +32,8 @@
   },
   "scripts": {
     "build": "tsc -p tsconfig.json",
+    "check:package": "node scripts/release-check.mjs",
+    "test:release": "node --test scripts/release-check.test.mjs",
     "test": "npm run build && node dist/codec.test.js && node dist/policy.test.js && node dist/cli.test.js"
   },
   "devDependencies": {